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         unsigned int standby : 1;
  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, 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
 130 static 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
 147 fail:
 148         coil->standby = 1;
 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, 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
 239 done:
 240         mutex_unlock(&coil->power_lock);
 241         return ret;
 242 }
 243
 244 static int ad5820_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 245 {
 246         return ad5820_set_power(sd, 1);
 247 }
 248
 249 static int ad5820_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 250 {
 251         return ad5820_set_power(sd, 0);
 252 }
 253
 254 static const struct v4l2_subdev_core_ops ad5820_core_ops = {
 255         .s_power = ad5820_set_power,
 256 };
 257
 258 static const struct v4l2_subdev_ops ad5820_ops = {
 259         .core = &ad5820_core_ops,
 260 };
 261
 262 static 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
 273 static 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
 285 static 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
 304 static 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
 339 cleanup2:
 340         mutex_destroy(&coil->power_lock);
 341 cleanup:
 342         media_entity_cleanup(&coil->subdev.entity);
 343         return ret;
 344 }
 345
 346 static 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
 358 static const struct i2c_device_id ad5820_id_table[] = {
 359         { AD5820_NAME, 0 },
 360         { }
 361 };
 362 MODULE_DEVICE_TABLE(i2c, ad5820_id_table);
 363
 364 static SIMPLE_DEV_PM_OPS(ad5820_pm, ad5820_suspend, ad5820_resume);
 365
 366 static 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
 376 module_i2c_driver(ad5820_i2c_driver);
 377
 378 MODULE_AUTHOR("Tuukka Toivonen");
 379 MODULE_DESCRIPTION("AD5820 camera lens driver");
 380 MODULE_LICENSE("GPL");