drivers/media/i2c/ad5820.c

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