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