History

[media] ad5820: Add driver for auto-focus coil

This adds support for AD5820 autofocus coil, found for example in Nokia N900 smartphone.

Pavel Machek committed 10 years ago

Commit bee3d511 parent 9887c863 files · +388 −0Browse files

Unified · Split

3 files
  1. drivers/media/i2c/Kconfig +7 −0
  2. drivers/media/i2c/Makefile +1 −0
  3. drivers/media/i2c/ad5820.c +380 −0
drivers/media/i2c/Kconfig+7−0
@@ -295,6 +295,13 @@ config VIDEO_ML86V7667 · 294 unmodified lines
295 To compile this driver as a module, choose M here: the295 To compile this driver as a module, choose M here: the
296 module will be called ml86v7667.296 module will be called ml86v7667.
297 297
298config VIDEO_AD5820
299 tristate "AD5820 lens voice coil support"
300 depends on I2C && VIDEO_V4L2 && MEDIA_CONTROLLER
301 ---help---
302 This is a driver for the AD5820 camera lens voice coil.
303 It is used for example in Nokia N900 (RX-51).
304
298config VIDEO_SAA7110305config VIDEO_SAA7110
299 tristate "Philips SAA7110 video decoder"306 tristate "Philips SAA7110 video decoder"
300 depends on VIDEO_V4L2 && I2C307 depends on VIDEO_V4L2 && I2C
drivers/media/i2c/Makefile+1−0
@@ -19,6 +19,7 @@ obj-$(CONFIG_VIDEO_SAA717X) += saa717x.o · 18 unmodified lines
19obj-$(CONFIG_VIDEO_SAA7127) += saa7127.o19obj-$(CONFIG_VIDEO_SAA7127) += saa7127.o
20obj-$(CONFIG_VIDEO_SAA7185) += saa7185.o20obj-$(CONFIG_VIDEO_SAA7185) += saa7185.o
21obj-$(CONFIG_VIDEO_SAA6752HS) += saa6752hs.o21obj-$(CONFIG_VIDEO_SAA6752HS) += saa6752hs.o
22obj-$(CONFIG_VIDEO_AD5820) += ad5820.o
22obj-$(CONFIG_VIDEO_ADV7170) += adv7170.o23obj-$(CONFIG_VIDEO_ADV7170) += adv7170.o
23obj-$(CONFIG_VIDEO_ADV7175) += adv7175.o24obj-$(CONFIG_VIDEO_ADV7175) += adv7175.o
24obj-$(CONFIG_VIDEO_ADV7180) += adv7180.o25obj-$(CONFIG_VIDEO_ADV7180) += adv7180.o
drivers/media/i2c/ad5820.c+380−0
@@ -0,0 +1,380 @@
1/*
2 * drivers/media/i2c/ad5820.c
3 *
4 * AD5820 DAC driver for camera voice coil focus.
5 *
6 * Copyright (C) 2008 Nokia Corporation
7 * Copyright (C) 2007 Texas Instruments
8 * Copyright (C) 2016 Pavel Machek <pavel@ucw.cz>
9 *
10 * Contact: Tuukka Toivonen <tuukkat76@gmail.com>
11 * Sakari Ailus <sakari.ailus@iki.fi>
12 *
13 * Based on af_d88.c by Texas Instruments.
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * version 2 as published by the Free Software Foundation.
18 *
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
23 */
24
25#include <linux/errno.h>
26#include <linux/i2c.h>
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/regulator/consumer.h>
30
31#include <media/v4l2-ctrls.h>
32#include <media/v4l2-device.h>
33#include <media/v4l2-subdev.h>
34
35#define AD5820_NAME "ad5820"
36
37/* Register definitions */
38#define AD5820_POWER_DOWN (1 << 15)
39#define AD5820_DAC_SHIFT 4
40#define AD5820_RAMP_MODE_LINEAR (0 << 3)
41#define AD5820_RAMP_MODE_64_16 (1 << 3)
42
43#define CODE_TO_RAMP_US(s) ((s) == 0 ? 0 : (1 << ((s) - 1)) * 50)
44#define RAMP_US_TO_CODE(c) fls(((c) + ((c)>>1)) / 50)
45
46#define to_ad5820_device(sd) container_of(sd, struct ad5820_device, subdev)
47
48struct ad5820_device {
49 struct v4l2_subdev subdev;
50 struct ad5820_platform_data *platform_data;
51 struct regulator *vana;
52
53 struct v4l2_ctrl_handler ctrls;
54 u32 focus_absolute;
55 u32 focus_ramp_time;
56 u32 focus_ramp_mode;
57
58 struct mutex power_lock;
59 int power_count;
60
61 int standby : 1;
62};
63
64static int ad5820_write(struct ad5820_device *coil, u16 data)
65{
66 struct i2c_client *client = v4l2_get_subdevdata(&coil->subdev);
67 struct i2c_msg msg;
68 int r;
69
70 if (!client->adapter)
71 return -ENODEV;
72
73 data = cpu_to_be16(data);
74 msg.addr = client->addr;
75 msg.flags = 0;
76 msg.len = 2;
77 msg.buf = (u8 *)&data;
78
79 r = i2c_transfer(client->adapter, &msg, 1);
80 if (r < 0) {
81 dev_err(&client->dev, "write failed, error %d\n", r);
82 return r;
83 }
84
85 return 0;
86}
87
88/*
89 * Calculate status word and write it to the device based on current
90 * values of V4L2 controls. It is assumed that the stored V4L2 control
91 * values are properly limited and rounded.
92 */
93static int ad5820_update_hw(struct ad5820_device *coil)
94{
95 u16 status;
96
97 status = RAMP_US_TO_CODE(coil->focus_ramp_time);
98 status |= coil->focus_ramp_mode
99 ? AD5820_RAMP_MODE_64_16 : AD5820_RAMP_MODE_LINEAR;
100 status |= coil->focus_absolute << AD5820_DAC_SHIFT;
101
102 if (coil->standby)
103 status |= AD5820_POWER_DOWN;
104
105 return ad5820_write(coil, status);
106}
107
108/*
109 * Power handling
110 */
111static int ad5820_power_off(struct ad5820_device *coil, int standby)
112{
113 int ret = 0, ret2;
114
115 /*
116 * Go to standby first as real power off my be denied by the hardware
117 * (single power line control for both coil and sensor).
118 */
119 if (standby) {
120 coil->standby = 1;
121 ret = ad5820_update_hw(coil);
122 }
123
124 ret2 = regulator_disable(coil->vana);
125 if (ret)
126 return ret;
127 return ret2;
128}
129
130static int ad5820_power_on(struct ad5820_device *coil, int restore)
131{
132 int ret;
133
134 ret = regulator_enable(coil->vana);
135 if (ret < 0)
136 return ret;
137
138 if (restore) {
139 /* Restore the hardware settings. */
140 coil->standby = 0;
141 ret = ad5820_update_hw(coil);
142 if (ret)
143 goto fail;
144 }
145 return 0;
146
147fail:
148 coil->standby = 1;
149 regulator_disable(coil->vana);
150
151 return ret;
152}
153
154/*
155 * V4L2 controls
156 */
157static int ad5820_set_ctrl(struct v4l2_ctrl *ctrl)
158{
159 struct ad5820_device *coil =
160 container_of(ctrl->handler, struct ad5820_device, ctrls);
161
162 switch (ctrl->id) {
163 case V4L2_CID_FOCUS_ABSOLUTE:
164 coil->focus_absolute = ctrl->val;
165 return ad5820_update_hw(coil);
166 }
167
168 return 0;
169}
170
171static const struct v4l2_ctrl_ops ad5820_ctrl_ops = {
172 .s_ctrl = ad5820_set_ctrl,
173};
174
175
176static int ad5820_init_controls(struct ad5820_device *coil)
177{
178 v4l2_ctrl_handler_init(&coil->ctrls, 1);
179
180 /*
181 * V4L2_CID_FOCUS_ABSOLUTE
182 *
183 * Minimum current is 0 mA, maximum is 100 mA. Thus, 1 code is
184 * equivalent to 100/1023 = 0.0978 mA. Nevertheless, we do not use [mA]
185 * for focus position, because it is meaningless for user. Meaningful
186 * would be to use focus distance or even its inverse, but since the
187 * driver doesn't have sufficiently knowledge to do the conversion, we
188 * will just use abstract codes here. In any case, smaller value = focus
189 * position farther from camera. The default zero value means focus at
190 * infinity, and also least current consumption.
191 */
192 v4l2_ctrl_new_std(&coil->ctrls, &ad5820_ctrl_ops,
193 V4L2_CID_FOCUS_ABSOLUTE, 0, 1023, 1, 0);
194
195 if (coil->ctrls.error)
196 return coil->ctrls.error;
197
198 coil->focus_absolute = 0;
199 coil->focus_ramp_time = 0;
200 coil->focus_ramp_mode = 0;
201
202 coil->subdev.ctrl_handler = &coil->ctrls;
203
204 return 0;
205}
206
207/*
208 * V4L2 subdev operations
209 */
210static int ad5820_registered(struct v4l2_subdev *subdev)
211{
212 struct ad5820_device *coil = to_ad5820_device(subdev);
213
214 return ad5820_init_controls(coil);
215}
216
217static int
218ad5820_set_power(struct v4l2_subdev *subdev, int on)
219{
220 struct ad5820_device *coil = to_ad5820_device(subdev);
221 int ret = 0;
222
223 mutex_lock(&coil->power_lock);
224
225 /*
226 * If the power count is modified from 0 to != 0 or from != 0 to 0,
227 * update the power state.
228 */
229 if (coil->power_count == !on) {
230 ret = on ? ad5820_power_on(coil, 1) : ad5820_power_off(coil, 1);
231 if (ret < 0)
232 goto done;
233 }
234
235 /* Update the power count. */
236 coil->power_count += on ? 1 : -1;
237 WARN_ON(coil->power_count < 0);
238
239done:
240 mutex_unlock(&coil->power_lock);
241 return ret;
242}
243
244static int ad5820_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
245{
246 return ad5820_set_power(sd, 1);
247}
248
249static int ad5820_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
250{
251 return ad5820_set_power(sd, 0);
252}
253
254static const struct v4l2_subdev_core_ops ad5820_core_ops = {
255 .s_power = ad5820_set_power,
256};
257
258static const struct v4l2_subdev_ops ad5820_ops = {
259 .core = &ad5820_core_ops,
260};
261
262static const struct v4l2_subdev_internal_ops ad5820_internal_ops = {
263 .registered = ad5820_registered,
264 .open = ad5820_open,
265 .close = ad5820_close,
266};
267
268/*
269 * I2C driver
270 */
271#ifdef CONFIG_PM
272
273static int ad5820_suspend(struct device *dev)
274{
275 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
276 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
277 struct ad5820_device *coil = to_ad5820_device(subdev);
278
279 if (!coil->power_count)
280 return 0;
281
282 return ad5820_power_off(coil, 0);
283}
284
285static int ad5820_resume(struct device *dev)
286{
287 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
288 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
289 struct ad5820_device *coil = to_ad5820_device(subdev);
290
291 if (!coil->power_count)
292 return 0;
293
294 return ad5820_power_on(coil, 1);
295}
296
297#else
298
299#define ad5820_suspend NULL
300#define ad5820_resume NULL
301
302#endif /* CONFIG_PM */
303
304static int ad5820_probe(struct i2c_client *client,
305 const struct i2c_device_id *devid)
306{
307 struct ad5820_device *coil;
308 int ret;
309
310 coil = devm_kzalloc(&client->dev, sizeof(*coil), GFP_KERNEL);
311 if (!coil)
312 return -ENOMEM;
313
314 coil->vana = devm_regulator_get(&client->dev, "VANA");
315 if (IS_ERR(coil->vana)) {
316 ret = PTR_ERR(coil->vana);
317 if (ret != -EPROBE_DEFER)
318 dev_err(&client->dev, "could not get regulator for vana\n");
319 return ret;
320 }
321
322 mutex_init(&coil->power_lock);
323
324 v4l2_i2c_subdev_init(&coil->subdev, client, &ad5820_ops);
325 coil->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
326 coil->subdev.internal_ops = &ad5820_internal_ops;
327 strcpy(coil->subdev.name, "ad5820 focus");
328
329 ret = media_entity_pads_init(&coil->subdev.entity, 0, NULL);
330 if (ret < 0)
331 goto cleanup2;
332
333 ret = v4l2_async_register_subdev(&coil->subdev);
334 if (ret < 0)
335 goto cleanup;
336
337 return ret;
338
339cleanup2:
340 mutex_destroy(&coil->power_lock);
341cleanup:
342 media_entity_cleanup(&coil->subdev.entity);
343 return ret;
344}
345
346static int __exit ad5820_remove(struct i2c_client *client)
347{
348 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
349 struct ad5820_device *coil = to_ad5820_device(subdev);
350
351 v4l2_device_unregister_subdev(&coil->subdev);
352 v4l2_ctrl_handler_free(&coil->ctrls);
353 media_entity_cleanup(&coil->subdev.entity);
354 mutex_destroy(&coil->power_lock);
355 return 0;
356}
357
358static const struct i2c_device_id ad5820_id_table[] = {
359 { AD5820_NAME, 0 },
360 { }
361};
362MODULE_DEVICE_TABLE(i2c, ad5820_id_table);
363
364static SIMPLE_DEV_PM_OPS(ad5820_pm, ad5820_suspend, ad5820_resume);
365
366static struct i2c_driver ad5820_i2c_driver = {
367 .driver = {
368 .name = AD5820_NAME,
369 .pm = &ad5820_pm,
370 },
371 .probe = ad5820_probe,
372 .remove = __exit_p(ad5820_remove),
373 .id_table = ad5820_id_table,
374};
375
376module_i2c_driver(ad5820_i2c_driver);
377
378MODULE_AUTHOR("Tuukka Toivonen");
379MODULE_DESCRIPTION("AD5820 camera lens driver");
380MODULE_LICENSE("GPL");

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t