2 * Copyright (c) 2015--2017 Intel Corporation.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License version
6 * 2 as published by the Free Software Foundation.
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.
14 #include <linux/acpi.h>
15 #include <linux/delay.h>
16 #include <linux/i2c.h>
17 #include <linux/module.h>
18 #include <linux/pm_runtime.h>
19 #include <media/v4l2-ctrls.h>
20 #include <media/v4l2-device.h>
22 #define DW9714_NAME "dw9714"
23 #define DW9714_MAX_FOCUS_POS 1023
25 * This acts as the minimum granularity of lens movement.
26 * Keep this value power of 2, so the control steps can be
27 * uniformly adjusted for gradual lens movement, with desired
28 * number of control steps.
30 #define DW9714_CTRL_STEPS 16
31 #define DW9714_CTRL_DELAY_US 1000
33 * S[3:2] = 0x00, codes per step for "Linear Slope Control"
34 * S[1:0] = 0x00, step period
36 #define DW9714_DEFAULT_S 0x0
37 #define DW9714_VAL(data, s) ((data) << 4 | (s))
39 /* dw9714 device structure */
40 struct dw9714_device
{
41 struct i2c_client
*client
;
42 struct v4l2_ctrl_handler ctrls_vcm
;
43 struct v4l2_subdev sd
;
47 static inline struct dw9714_device
*to_dw9714_vcm(struct v4l2_ctrl
*ctrl
)
49 return container_of(ctrl
->handler
, struct dw9714_device
, ctrls_vcm
);
52 static inline struct dw9714_device
*sd_to_dw9714_vcm(struct v4l2_subdev
*subdev
)
54 return container_of(subdev
, struct dw9714_device
, sd
);
57 static int dw9714_i2c_write(struct i2c_client
*client
, u16 data
)
60 u16 val
= cpu_to_be16(data
);
62 ret
= i2c_master_send(client
, (const char *)&val
, sizeof(val
));
63 if (ret
!= sizeof(val
)) {
64 dev_err(&client
->dev
, "I2C write fail\n");
70 static int dw9714_t_focus_vcm(struct dw9714_device
*dw9714_dev
, u16 val
)
72 struct i2c_client
*client
= dw9714_dev
->client
;
74 dw9714_dev
->current_val
= val
;
76 return dw9714_i2c_write(client
, DW9714_VAL(val
, DW9714_DEFAULT_S
));
79 static int dw9714_set_ctrl(struct v4l2_ctrl
*ctrl
)
81 struct dw9714_device
*dev_vcm
= to_dw9714_vcm(ctrl
);
83 if (ctrl
->id
== V4L2_CID_FOCUS_ABSOLUTE
)
84 return dw9714_t_focus_vcm(dev_vcm
, ctrl
->val
);
89 static const struct v4l2_ctrl_ops dw9714_vcm_ctrl_ops
= {
90 .s_ctrl
= dw9714_set_ctrl
,
93 static int dw9714_open(struct v4l2_subdev
*sd
, struct v4l2_subdev_fh
*fh
)
95 struct dw9714_device
*dw9714_dev
= sd_to_dw9714_vcm(sd
);
96 struct device
*dev
= &dw9714_dev
->client
->dev
;
99 rval
= pm_runtime_get_sync(dev
);
101 pm_runtime_put_noidle(dev
);
108 static int dw9714_close(struct v4l2_subdev
*sd
, struct v4l2_subdev_fh
*fh
)
110 struct dw9714_device
*dw9714_dev
= sd_to_dw9714_vcm(sd
);
111 struct device
*dev
= &dw9714_dev
->client
->dev
;
118 static const struct v4l2_subdev_internal_ops dw9714_int_ops
= {
120 .close
= dw9714_close
,
123 static const struct v4l2_subdev_ops dw9714_ops
= { };
125 static void dw9714_subdev_cleanup(struct dw9714_device
*dw9714_dev
)
127 v4l2_async_unregister_subdev(&dw9714_dev
->sd
);
128 v4l2_ctrl_handler_free(&dw9714_dev
->ctrls_vcm
);
129 media_entity_cleanup(&dw9714_dev
->sd
.entity
);
132 static int dw9714_init_controls(struct dw9714_device
*dev_vcm
)
134 struct v4l2_ctrl_handler
*hdl
= &dev_vcm
->ctrls_vcm
;
135 const struct v4l2_ctrl_ops
*ops
= &dw9714_vcm_ctrl_ops
;
136 struct i2c_client
*client
= dev_vcm
->client
;
138 v4l2_ctrl_handler_init(hdl
, 1);
140 v4l2_ctrl_new_std(hdl
, ops
, V4L2_CID_FOCUS_ABSOLUTE
,
141 0, DW9714_MAX_FOCUS_POS
, DW9714_CTRL_STEPS
, 0);
144 dev_err(&client
->dev
, "%s fail error: 0x%x\n",
145 __func__
, hdl
->error
);
146 dev_vcm
->sd
.ctrl_handler
= hdl
;
150 static int dw9714_probe(struct i2c_client
*client
,
151 const struct i2c_device_id
*devid
)
153 struct dw9714_device
*dw9714_dev
;
156 dw9714_dev
= devm_kzalloc(&client
->dev
, sizeof(*dw9714_dev
),
158 if (dw9714_dev
== NULL
)
161 dw9714_dev
->client
= client
;
163 v4l2_i2c_subdev_init(&dw9714_dev
->sd
, client
, &dw9714_ops
);
164 dw9714_dev
->sd
.flags
|= V4L2_SUBDEV_FL_HAS_DEVNODE
;
165 dw9714_dev
->sd
.internal_ops
= &dw9714_int_ops
;
167 rval
= dw9714_init_controls(dw9714_dev
);
171 rval
= media_entity_pads_init(&dw9714_dev
->sd
.entity
, 0, NULL
);
175 dw9714_dev
->sd
.entity
.function
= MEDIA_ENT_F_LENS
;
177 rval
= v4l2_async_register_subdev(&dw9714_dev
->sd
);
181 pm_runtime_set_active(&client
->dev
);
182 pm_runtime_enable(&client
->dev
);
187 dw9714_subdev_cleanup(dw9714_dev
);
188 dev_err(&client
->dev
, "Probe failed: %d\n", rval
);
192 static int dw9714_remove(struct i2c_client
*client
)
194 struct v4l2_subdev
*sd
= i2c_get_clientdata(client
);
195 struct dw9714_device
*dw9714_dev
= sd_to_dw9714_vcm(sd
);
197 pm_runtime_disable(&client
->dev
);
198 dw9714_subdev_cleanup(dw9714_dev
);
204 * This function sets the vcm position, so it consumes least current
205 * The lens position is gradually moved in units of DW9714_CTRL_STEPS,
206 * to make the movements smoothly.
208 static int __maybe_unused
dw9714_vcm_suspend(struct device
*dev
)
210 struct i2c_client
*client
= to_i2c_client(dev
);
211 struct v4l2_subdev
*sd
= i2c_get_clientdata(client
);
212 struct dw9714_device
*dw9714_dev
= sd_to_dw9714_vcm(sd
);
215 for (val
= dw9714_dev
->current_val
& ~(DW9714_CTRL_STEPS
- 1);
216 val
>= 0; val
-= DW9714_CTRL_STEPS
) {
217 ret
= dw9714_i2c_write(client
,
218 DW9714_VAL(val
, DW9714_DEFAULT_S
));
220 dev_err_once(dev
, "%s I2C failure: %d", __func__
, ret
);
221 usleep_range(DW9714_CTRL_DELAY_US
, DW9714_CTRL_DELAY_US
+ 10);
227 * This function sets the vcm position to the value set by the user
228 * through v4l2_ctrl_ops s_ctrl handler
229 * The lens position is gradually moved in units of DW9714_CTRL_STEPS,
230 * to make the movements smoothly.
232 static int __maybe_unused
dw9714_vcm_resume(struct device
*dev
)
234 struct i2c_client
*client
= to_i2c_client(dev
);
235 struct v4l2_subdev
*sd
= i2c_get_clientdata(client
);
236 struct dw9714_device
*dw9714_dev
= sd_to_dw9714_vcm(sd
);
239 for (val
= dw9714_dev
->current_val
% DW9714_CTRL_STEPS
;
240 val
< dw9714_dev
->current_val
+ DW9714_CTRL_STEPS
- 1;
241 val
+= DW9714_CTRL_STEPS
) {
242 ret
= dw9714_i2c_write(client
,
243 DW9714_VAL(val
, DW9714_DEFAULT_S
));
245 dev_err_ratelimited(dev
, "%s I2C failure: %d",
247 usleep_range(DW9714_CTRL_DELAY_US
, DW9714_CTRL_DELAY_US
+ 10);
254 static const struct acpi_device_id dw9714_acpi_match
[] = {
257 MODULE_DEVICE_TABLE(acpi
, dw9714_acpi_match
);
260 static const struct i2c_device_id dw9714_id_table
[] = {
265 MODULE_DEVICE_TABLE(i2c
, dw9714_id_table
);
267 static const struct dev_pm_ops dw9714_pm_ops
= {
268 SET_SYSTEM_SLEEP_PM_OPS(dw9714_vcm_suspend
, dw9714_vcm_resume
)
269 SET_RUNTIME_PM_OPS(dw9714_vcm_suspend
, dw9714_vcm_resume
, NULL
)
272 static struct i2c_driver dw9714_i2c_driver
= {
275 .pm
= &dw9714_pm_ops
,
276 .acpi_match_table
= ACPI_PTR(dw9714_acpi_match
),
278 .probe
= dw9714_probe
,
279 .remove
= dw9714_remove
,
280 .id_table
= dw9714_id_table
,
283 module_i2c_driver(dw9714_i2c_driver
);
285 MODULE_AUTHOR("Tianshu Qiu <tian.shu.qiu@intel.com>");
286 MODULE_AUTHOR("Jian Xu Zheng <jian.xu.zheng@intel.com>");
287 MODULE_AUTHOR("Yuning Pu <yuning.pu@intel.com>");
288 MODULE_AUTHOR("Jouni Ukkonen <jouni.ukkonen@intel.com>");
289 MODULE_AUTHOR("Tommi Franttila <tommi.franttila@intel.com>");
290 MODULE_DESCRIPTION("DW9714 VCM driver");
291 MODULE_LICENSE("GPL v2");