drivers/media/i2c/adp1653.c

   1 /*
   2  * drivers/media/i2c/adp1653.c
   3  *
   4  * Copyright (C) 2008--2011 Nokia Corporation
   5  *
   6  * Contact: Sakari Ailus <sakari.ailus@iki.fi>
   7  *
   8  * Contributors:
   9  *      Sakari Ailus <sakari.ailus@iki.fi>
  10  *      Tuukka Toivonen <tuukkat76@gmail.com>
  11  *      Pavel Machek <pavel@ucw.cz>
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * version 2 as published by the Free Software Foundation.
  16  *
  17  * This program is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  25  * 02110-1301 USA
  26  *
  27  * TODO:
  28  * - fault interrupt handling
  29  * - hardware strobe
  30  * - power doesn't need to be ON if all lights are off
  31  *
  32  */
  33
  34 #include <linux/delay.h>
  35 #include <linux/module.h>
  36 #include <linux/i2c.h>
  37 #include <linux/slab.h>
  38 #include <linux/of.h>
  39 #include <linux/gpio/consumer.h>
  40 #include <media/i2c/adp1653.h>
  41 #include <media/v4l2-device.h>
  42
  43 #define TIMEOUT_MAX             820000
  44 #define TIMEOUT_STEP            54600
  45 #define TIMEOUT_MIN             (TIMEOUT_MAX - ADP1653_REG_CONFIG_TMR_SET_MAX \
  46                                  * TIMEOUT_STEP)
  47 #define TIMEOUT_US_TO_CODE(t)   ((TIMEOUT_MAX + (TIMEOUT_STEP / 2) - (t)) \
  48                                  / TIMEOUT_STEP)
  49 #define TIMEOUT_CODE_TO_US(c)   (TIMEOUT_MAX - (c) * TIMEOUT_STEP)
  50
  51 /* Write values into ADP1653 registers. */
  52 static int adp1653_update_hw(struct adp1653_flash *flash)
  53 {
  54         struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
  55         u8 out_sel;
  56         u8 config = 0;
  57         int rval;
  58
  59         out_sel = ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
  60                 flash->indicator_intensity->val)
  61                 << ADP1653_REG_OUT_SEL_ILED_SHIFT;
  62
  63         switch (flash->led_mode->val) {
  64         case V4L2_FLASH_LED_MODE_NONE:
  65                 break;
  66         case V4L2_FLASH_LED_MODE_FLASH:
  67                 /* Flash mode, light on with strobe, duration from timer */
  68                 config = ADP1653_REG_CONFIG_TMR_CFG;
  69                 config |= TIMEOUT_US_TO_CODE(flash->flash_timeout->val)
  70                           << ADP1653_REG_CONFIG_TMR_SET_SHIFT;
  71                 break;
  72         case V4L2_FLASH_LED_MODE_TORCH:
  73                 /* Torch mode, light immediately on, duration indefinite */
  74                 out_sel |= ADP1653_FLASH_INTENSITY_mA_TO_REG(
  75                         flash->torch_intensity->val)
  76                         << ADP1653_REG_OUT_SEL_HPLED_SHIFT;
  77                 break;
  78         }
  79
  80         rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, out_sel);
  81         if (rval < 0)
  82                 return rval;
  83
  84         rval = i2c_smbus_write_byte_data(client, ADP1653_REG_CONFIG, config);
  85         if (rval < 0)
  86                 return rval;
  87
  88         return 0;
  89 }
  90
  91 static int adp1653_get_fault(struct adp1653_flash *flash)
  92 {
  93         struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
  94         int fault;
  95         int rval;
  96
  97         fault = i2c_smbus_read_byte_data(client, ADP1653_REG_FAULT);
  98         if (IS_ERR_VALUE(fault))
  99                 return fault;
 100
 101         flash->fault |= fault;
 102
 103         if (!flash->fault)
 104                 return 0;
 105
 106         /* Clear faults. */
 107         rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, 0);
 108         if (IS_ERR_VALUE(rval))
 109                 return rval;
 110
 111         flash->led_mode->val = V4L2_FLASH_LED_MODE_NONE;
 112
 113         rval = adp1653_update_hw(flash);
 114         if (IS_ERR_VALUE(rval))
 115                 return rval;
 116
 117         return flash->fault;
 118 }
 119
 120 static int adp1653_strobe(struct adp1653_flash *flash, int enable)
 121 {
 122         struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
 123         u8 out_sel = ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
 124                 flash->indicator_intensity->val)
 125                 << ADP1653_REG_OUT_SEL_ILED_SHIFT;
 126         int rval;
 127
 128         if (flash->led_mode->val != V4L2_FLASH_LED_MODE_FLASH)
 129                 return -EBUSY;
 130
 131         if (!enable)
 132                 return i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL,
 133                                                  out_sel);
 134
 135         out_sel |= ADP1653_FLASH_INTENSITY_mA_TO_REG(
 136                 flash->flash_intensity->val)
 137                 << ADP1653_REG_OUT_SEL_HPLED_SHIFT;
 138         rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, out_sel);
 139         if (rval)
 140                 return rval;
 141
 142         /* Software strobe using i2c */
 143         rval = i2c_smbus_write_byte_data(client, ADP1653_REG_SW_STROBE,
 144                 ADP1653_REG_SW_STROBE_SW_STROBE);
 145         if (rval)
 146                 return rval;
 147         return i2c_smbus_write_byte_data(client, ADP1653_REG_SW_STROBE, 0);
 148 }
 149
 150 /* --------------------------------------------------------------------------
 151  * V4L2 controls
 152  */
 153
 154 static int adp1653_get_ctrl(struct v4l2_ctrl *ctrl)
 155 {
 156         struct adp1653_flash *flash =
 157                 container_of(ctrl->handler, struct adp1653_flash, ctrls);
 158         int rval;
 159
 160         rval = adp1653_get_fault(flash);
 161         if (IS_ERR_VALUE(rval))
 162                 return rval;
 163
 164         ctrl->cur.val = 0;
 165
 166         if (flash->fault & ADP1653_REG_FAULT_FLT_SCP)
 167                 ctrl->cur.val |= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
 168         if (flash->fault & ADP1653_REG_FAULT_FLT_OT)
 169                 ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
 170         if (flash->fault & ADP1653_REG_FAULT_FLT_TMR)
 171                 ctrl->cur.val |= V4L2_FLASH_FAULT_TIMEOUT;
 172         if (flash->fault & ADP1653_REG_FAULT_FLT_OV)
 173                 ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_VOLTAGE;
 174
 175         flash->fault = 0;
 176
 177         return 0;
 178 }
 179
 180 static int adp1653_set_ctrl(struct v4l2_ctrl *ctrl)
 181 {
 182         struct adp1653_flash *flash =
 183                 container_of(ctrl->handler, struct adp1653_flash, ctrls);
 184         int rval;
 185
 186         rval = adp1653_get_fault(flash);
 187         if (IS_ERR_VALUE(rval))
 188                 return rval;
 189         if ((rval & (ADP1653_REG_FAULT_FLT_SCP |
 190                      ADP1653_REG_FAULT_FLT_OT |
 191                      ADP1653_REG_FAULT_FLT_OV)) &&
 192             (ctrl->id == V4L2_CID_FLASH_STROBE ||
 193              ctrl->id == V4L2_CID_FLASH_TORCH_INTENSITY ||
 194              ctrl->id == V4L2_CID_FLASH_LED_MODE))
 195                 return -EBUSY;
 196
 197         switch (ctrl->id) {
 198         case V4L2_CID_FLASH_STROBE:
 199                 return adp1653_strobe(flash, 1);
 200         case V4L2_CID_FLASH_STROBE_STOP:
 201                 return adp1653_strobe(flash, 0);
 202         }
 203
 204         return adp1653_update_hw(flash);
 205 }
 206
 207 static const struct v4l2_ctrl_ops adp1653_ctrl_ops = {
 208         .g_volatile_ctrl = adp1653_get_ctrl,
 209         .s_ctrl = adp1653_set_ctrl,
 210 };
 211
 212 static int adp1653_init_controls(struct adp1653_flash *flash)
 213 {
 214         struct v4l2_ctrl *fault;
 215
 216         v4l2_ctrl_handler_init(&flash->ctrls, 9);
 217
 218         flash->led_mode =
 219                 v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,
 220                                        V4L2_CID_FLASH_LED_MODE,
 221                                        V4L2_FLASH_LED_MODE_TORCH, ~0x7, 0);
 222         v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,
 223                                V4L2_CID_FLASH_STROBE_SOURCE,
 224                                V4L2_FLASH_STROBE_SOURCE_SOFTWARE, ~0x1, 0);
 225         v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 226                           V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
 227         v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 228                           V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
 229         flash->flash_timeout =
 230                 v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 231                                   V4L2_CID_FLASH_TIMEOUT, TIMEOUT_MIN,
 232                                   flash->platform_data->max_flash_timeout,
 233                                   TIMEOUT_STEP,
 234                                   flash->platform_data->max_flash_timeout);
 235         flash->flash_intensity =
 236                 v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 237                                   V4L2_CID_FLASH_INTENSITY,
 238                                   ADP1653_FLASH_INTENSITY_MIN,
 239                                   flash->platform_data->max_flash_intensity,
 240                                   1, flash->platform_data->max_flash_intensity);
 241         flash->torch_intensity =
 242                 v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 243                                   V4L2_CID_FLASH_TORCH_INTENSITY,
 244                                   ADP1653_TORCH_INTENSITY_MIN,
 245                                   flash->platform_data->max_torch_intensity,
 246                                   ADP1653_FLASH_INTENSITY_STEP,
 247                                   flash->platform_data->max_torch_intensity);
 248         flash->indicator_intensity =
 249                 v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 250                                   V4L2_CID_FLASH_INDICATOR_INTENSITY,
 251                                   ADP1653_INDICATOR_INTENSITY_MIN,
 252                                   flash->platform_data->max_indicator_intensity,
 253                                   ADP1653_INDICATOR_INTENSITY_STEP,
 254                                   ADP1653_INDICATOR_INTENSITY_MIN);
 255         fault = v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
 256                                   V4L2_CID_FLASH_FAULT, 0,
 257                                   V4L2_FLASH_FAULT_OVER_VOLTAGE
 258                                   | V4L2_FLASH_FAULT_OVER_TEMPERATURE
 259                                   | V4L2_FLASH_FAULT_SHORT_CIRCUIT, 0, 0);
 260
 261         if (flash->ctrls.error)
 262                 return flash->ctrls.error;
 263
 264         fault->flags |= V4L2_CTRL_FLAG_VOLATILE;
 265
 266         flash->subdev.ctrl_handler = &flash->ctrls;
 267         return 0;
 268 }
 269
 270 /* --------------------------------------------------------------------------
 271  * V4L2 subdev operations
 272  */
 273
 274 static int
 275 adp1653_init_device(struct adp1653_flash *flash)
 276 {
 277         struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
 278         int rval;
 279
 280         /* Clear FAULT register by writing zero to OUT_SEL */
 281         rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, 0);
 282         if (rval < 0) {
 283                 dev_err(&client->dev, "failed writing fault register\n");
 284                 return -EIO;
 285         }
 286
 287         mutex_lock(flash->ctrls.lock);
 288         /* Reset faults before reading new ones. */
 289         flash->fault = 0;
 290         rval = adp1653_get_fault(flash);
 291         mutex_unlock(flash->ctrls.lock);
 292         if (rval > 0) {
 293                 dev_err(&client->dev, "faults detected: 0x%1.1x\n", rval);
 294                 return -EIO;
 295         }
 296
 297         mutex_lock(flash->ctrls.lock);
 298         rval = adp1653_update_hw(flash);
 299         mutex_unlock(flash->ctrls.lock);
 300         if (rval) {
 301                 dev_err(&client->dev,
 302                         "adp1653_update_hw failed at %s\n", __func__);
 303                 return -EIO;
 304         }
 305
 306         return 0;
 307 }
 308
 309 static int
 310 __adp1653_set_power(struct adp1653_flash *flash, int on)
 311 {
 312         int ret;
 313
 314         if (flash->platform_data->power) {
 315                 ret = flash->platform_data->power(&flash->subdev, on);
 316                 if (ret < 0)
 317                         return ret;
 318         } else {
 319                 gpiod_set_value(flash->platform_data->enable_gpio, on);
 320                 if (on)
 321                         /* Some delay is apparently required. */
 322                         udelay(20);
 323         }
 324
 325         if (!on)
 326                 return 0;
 327
 328         ret = adp1653_init_device(flash);
 329         if (ret >= 0)
 330                 return ret;
 331
 332         if (flash->platform_data->power)
 333                 flash->platform_data->power(&flash->subdev, 0);
 334         else
 335                 gpiod_set_value(flash->platform_data->enable_gpio, 0);
 336
 337         return ret;
 338 }
 339
 340 static int
 341 adp1653_set_power(struct v4l2_subdev *subdev, int on)
 342 {
 343         struct adp1653_flash *flash = to_adp1653_flash(subdev);
 344         int ret = 0;
 345
 346         mutex_lock(&flash->power_lock);
 347
 348         /* If the power count is modified from 0 to != 0 or from != 0 to 0,
 349          * update the power state.
 350          */
 351         if (flash->power_count == !on) {
 352                 ret = __adp1653_set_power(flash, !!on);
 353                 if (ret < 0)
 354                         goto done;
 355         }
 356
 357         /* Update the power count. */
 358         flash->power_count += on ? 1 : -1;
 359         WARN_ON(flash->power_count < 0);
 360
 361 done:
 362         mutex_unlock(&flash->power_lock);
 363         return ret;
 364 }
 365
 366 static int adp1653_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 367 {
 368         return adp1653_set_power(sd, 1);
 369 }
 370
 371 static int adp1653_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 372 {
 373         return adp1653_set_power(sd, 0);
 374 }
 375
 376 static const struct v4l2_subdev_core_ops adp1653_core_ops = {
 377         .s_power = adp1653_set_power,
 378 };
 379
 380 static const struct v4l2_subdev_ops adp1653_ops = {
 381         .core = &adp1653_core_ops,
 382 };
 383
 384 static const struct v4l2_subdev_internal_ops adp1653_internal_ops = {
 385         .open = adp1653_open,
 386         .close = adp1653_close,
 387 };
 388
 389 /* --------------------------------------------------------------------------
 390  * I2C driver
 391  */
 392 #ifdef CONFIG_PM
 393
 394 static int adp1653_suspend(struct device *dev)
 395 {
 396         struct i2c_client *client = to_i2c_client(dev);
 397         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
 398         struct adp1653_flash *flash = to_adp1653_flash(subdev);
 399
 400         if (!flash->power_count)
 401                 return 0;
 402
 403         return __adp1653_set_power(flash, 0);
 404 }
 405
 406 static int adp1653_resume(struct device *dev)
 407 {
 408         struct i2c_client *client = to_i2c_client(dev);
 409         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
 410         struct adp1653_flash *flash = to_adp1653_flash(subdev);
 411
 412         if (!flash->power_count)
 413                 return 0;
 414
 415         return __adp1653_set_power(flash, 1);
 416 }
 417
 418 #else
 419
 420 #define adp1653_suspend NULL
 421 #define adp1653_resume  NULL
 422
 423 #endif /* CONFIG_PM */
 424
 425 static int adp1653_of_init(struct i2c_client *client,
 426                            struct adp1653_flash *flash,
 427                            struct device_node *node)
 428 {
 429         struct adp1653_platform_data *pd;
 430         struct device_node *child;
 431
 432         pd = devm_kzalloc(&client->dev, sizeof(*pd), GFP_KERNEL);
 433         if (!pd)
 434                 return -ENOMEM;
 435         flash->platform_data = pd;
 436
 437         child = of_get_child_by_name(node, "flash");
 438         if (!child)
 439                 return -EINVAL;
 440
 441         if (of_property_read_u32(child, "flash-timeout-us",
 442                                  &pd->max_flash_timeout))
 443                 goto err;
 444
 445         if (of_property_read_u32(child, "flash-max-microamp",
 446                                  &pd->max_flash_intensity))
 447                 goto err;
 448
 449         pd->max_flash_intensity /= 1000;
 450
 451         if (of_property_read_u32(child, "led-max-microamp",
 452                                  &pd->max_torch_intensity))
 453                 goto err;
 454
 455         pd->max_torch_intensity /= 1000;
 456         of_node_put(child);
 457
 458         child = of_get_child_by_name(node, "indicator");
 459         if (!child)
 460                 return -EINVAL;
 461
 462         if (of_property_read_u32(child, "led-max-microamp",
 463                                  &pd->max_indicator_intensity))
 464                 goto err;
 465
 466         of_node_put(child);
 467
 468         pd->enable_gpio = devm_gpiod_get(&client->dev, "enable", GPIOD_OUT_LOW);
 469         if (!pd->enable_gpio) {
 470                 dev_err(&client->dev, "Error getting GPIO\n");
 471                 return -EINVAL;
 472         }
 473
 474         return 0;
 475 err:
 476         dev_err(&client->dev, "Required property not found\n");
 477         of_node_put(child);
 478         return -EINVAL;
 479 }
 480
 481
 482 static int adp1653_probe(struct i2c_client *client,
 483                          const struct i2c_device_id *devid)
 484 {
 485         struct adp1653_flash *flash;
 486         int ret;
 487
 488         flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL);
 489         if (flash == NULL)
 490                 return -ENOMEM;
 491
 492         if (client->dev.of_node) {
 493                 ret = adp1653_of_init(client, flash, client->dev.of_node);
 494                 if (ret)
 495                         return ret;
 496         } else {
 497                 if (!client->dev.platform_data) {
 498                         dev_err(&client->dev,
 499                                 "Neither DT not platform data provided\n");
 500                         return -EINVAL;
 501                 }
 502                 flash->platform_data = client->dev.platform_data;
 503         }
 504
 505         mutex_init(&flash->power_lock);
 506
 507         v4l2_i2c_subdev_init(&flash->subdev, client, &adp1653_ops);
 508         flash->subdev.internal_ops = &adp1653_internal_ops;
 509         flash->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 510
 511         ret = adp1653_init_controls(flash);
 512         if (ret)
 513                 goto free_and_quit;
 514
 515         ret = media_entity_pads_init(&flash->subdev.entity, 0, NULL);
 516         if (ret < 0)
 517                 goto free_and_quit;
 518
 519         flash->subdev.entity.function = MEDIA_ENT_F_FLASH;
 520
 521         return 0;
 522
 523 free_and_quit:
 524         dev_err(&client->dev, "adp1653: failed to register device\n");
 525         v4l2_ctrl_handler_free(&flash->ctrls);
 526         return ret;
 527 }
 528
 529 static int adp1653_remove(struct i2c_client *client)
 530 {
 531         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
 532         struct adp1653_flash *flash = to_adp1653_flash(subdev);
 533
 534         v4l2_device_unregister_subdev(&flash->subdev);
 535         v4l2_ctrl_handler_free(&flash->ctrls);
 536         media_entity_cleanup(&flash->subdev.entity);
 537
 538         return 0;
 539 }
 540
 541 static const struct i2c_device_id adp1653_id_table[] = {
 542         { ADP1653_NAME, 0 },
 543         { }
 544 };
 545 MODULE_DEVICE_TABLE(i2c, adp1653_id_table);
 546
 547 static const struct dev_pm_ops adp1653_pm_ops = {
 548         .suspend        = adp1653_suspend,
 549         .resume         = adp1653_resume,
 550 };
 551
 552 static struct i2c_driver adp1653_i2c_driver = {
 553         .driver         = {
 554                 .name   = ADP1653_NAME,
 555                 .pm     = &adp1653_pm_ops,
 556         },
 557         .probe          = adp1653_probe,
 558         .remove         = adp1653_remove,
 559         .id_table       = adp1653_id_table,
 560 };
 561
 562 module_i2c_driver(adp1653_i2c_driver);
 563
 564 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
 565 MODULE_DESCRIPTION("Analog Devices ADP1653 LED flash driver");
 566 MODULE_LICENSE("GPL");