drivers/media/i2c/ad5820.c

   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
  48 struct 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         bool standby;
  62 };
  63
  64 static 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  */
  93 static 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  */
 111 static int ad5820_power_off(struct ad5820_device *coil, bool 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 = true;
 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
 130 static int ad5820_power_on(struct ad5820_device *coil, bool 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 = false;
 141                 ret = ad5820_update_hw(coil);
 142                 if (ret)
 143                         goto fail;
 144         }
 145         return 0;
 146
 147 fail:
 148         coil->standby = true;
 149         regulator_disable(coil->vana);
 150
 151         return ret;
 152 }
 153
 154 /*
 155  * V4L2 controls
 156  */
 157 static 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
 171 static const struct v4l2_ctrl_ops ad5820_ctrl_ops = {
 172         .s_ctrl = ad5820_set_ctrl,
 173 };
 174
 175
 176 static 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  */
 210 static 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
 217 static int
 218 ad5820_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, true) :
 231                         ad5820_power_off(coil, true);
 232                 if (ret < 0)
 233                         goto done;
 234         }
 235
 236         /* Update the power count. */
 237         coil->power_count += on ? 1 : -1;
 238         WARN_ON(coil->power_count < 0);
 239
 240 done:
 241         mutex_unlock(&coil->power_lock);
 242         return ret;
 243 }
 244
 245 static int ad5820_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 246 {
 247         return ad5820_set_power(sd, 1);
 248 }
 249
 250 static int ad5820_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 251 {
 252         return ad5820_set_power(sd, 0);
 253 }
 254
 255 static const struct v4l2_subdev_core_ops ad5820_core_ops = {
 256         .s_power = ad5820_set_power,
 257 };
 258
 259 static const struct v4l2_subdev_ops ad5820_ops = {
 260         .core = &ad5820_core_ops,
 261 };
 262
 263 static const struct v4l2_subdev_internal_ops ad5820_internal_ops = {
 264         .registered = ad5820_registered,
 265         .open = ad5820_open,
 266         .close = ad5820_close,
 267 };
 268
 269 /*
 270  * I2C driver
 271  */
 272 static int __maybe_unused ad5820_suspend(struct device *dev)
 273 {
 274         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 275         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
 276         struct ad5820_device *coil = to_ad5820_device(subdev);
 277
 278         if (!coil->power_count)
 279                 return 0;
 280
 281         return ad5820_power_off(coil, false);
 282 }
 283
 284 static int __maybe_unused ad5820_resume(struct device *dev)
 285 {
 286         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 287         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
 288         struct ad5820_device *coil = to_ad5820_device(subdev);
 289
 290         if (!coil->power_count)
 291                 return 0;
 292
 293         return ad5820_power_on(coil, true);
 294 }
 295
 296 static int ad5820_probe(struct i2c_client *client,
 297                         const struct i2c_device_id *devid)
 298 {
 299         struct ad5820_device *coil;
 300         int ret;
 301
 302         coil = devm_kzalloc(&client->dev, sizeof(*coil), GFP_KERNEL);
 303         if (!coil)
 304                 return -ENOMEM;
 305
 306         coil->vana = devm_regulator_get(&client->dev, "VANA");
 307         if (IS_ERR(coil->vana)) {
 308                 ret = PTR_ERR(coil->vana);
 309                 if (ret != -EPROBE_DEFER)
 310                         dev_err(&client->dev, "could not get regulator for vana\n");
 311                 return ret;
 312         }
 313
 314         mutex_init(&coil->power_lock);
 315
 316         v4l2_i2c_subdev_init(&coil->subdev, client, &ad5820_ops);
 317         coil->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 318         coil->subdev.internal_ops = &ad5820_internal_ops;
 319         strcpy(coil->subdev.name, "ad5820 focus");
 320
 321         ret = media_entity_pads_init(&coil->subdev.entity, 0, NULL);
 322         if (ret < 0)
 323                 goto cleanup2;
 324
 325         ret = v4l2_async_register_subdev(&coil->subdev);
 326         if (ret < 0)
 327                 goto cleanup;
 328
 329         return ret;
 330
 331 cleanup2:
 332         mutex_destroy(&coil->power_lock);
 333 cleanup:
 334         media_entity_cleanup(&coil->subdev.entity);
 335         return ret;
 336 }
 337
 338 static int __exit ad5820_remove(struct i2c_client *client)
 339 {
 340         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
 341         struct ad5820_device *coil = to_ad5820_device(subdev);
 342
 343         v4l2_device_unregister_subdev(&coil->subdev);
 344         v4l2_ctrl_handler_free(&coil->ctrls);
 345         media_entity_cleanup(&coil->subdev.entity);
 346         mutex_destroy(&coil->power_lock);
 347         return 0;
 348 }
 349
 350 static const struct i2c_device_id ad5820_id_table[] = {
 351         { AD5820_NAME, 0 },
 352         { }
 353 };
 354 MODULE_DEVICE_TABLE(i2c, ad5820_id_table);
 355
 356 static SIMPLE_DEV_PM_OPS(ad5820_pm, ad5820_suspend, ad5820_resume);
 357
 358 static struct i2c_driver ad5820_i2c_driver = {
 359         .driver         = {
 360                 .name   = AD5820_NAME,
 361                 .pm     = &ad5820_pm,
 362         },
 363         .probe          = ad5820_probe,
 364         .remove         = __exit_p(ad5820_remove),
 365         .id_table       = ad5820_id_table,
 366 };
 367
 368 module_i2c_driver(ad5820_i2c_driver);
 369
 370 MODULE_AUTHOR("Tuukka Toivonen");
 371 MODULE_DESCRIPTION("AD5820 camera lens driver");
 372 MODULE_LICENSE("GPL");