media/i2c/lm3560.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * drivers/media/i2c/lm3560.c
0004  * General device driver for TI lm3559, lm3560, FLASH LED Driver
0005  *
0006  * Copyright (C) 2013 Texas Instruments
0007  *
0008  * Contact: Daniel Jeong <gshark.jeong@gmail.com>
0009  *          Ldd-Mlp <ldd-mlp@list.ti.com>
0010  */
0011
0012 #include <linux/delay.h>
0013 #include <linux/module.h>
0014 #include <linux/i2c.h>
0015 #include <linux/slab.h>
0016 #include <linux/mutex.h>
0017 #include <linux/regmap.h>
0018 #include <linux/videodev2.h>
0019 #include <media/i2c/lm3560.h>
0020 #include <media/v4l2-ctrls.h>
0021 #include <media/v4l2-device.h>
0022
0023 /* registers definitions */
0024 #define REG_ENABLE      0x10
0025 #define REG_TORCH_BR    0xa0
0026 #define REG_FLASH_BR    0xb0
0027 #define REG_FLASH_TOUT  0xc0
0028 #define REG_FLAG        0xd0
0029 #define REG_CONFIG1     0xe0
0030
0031 /* fault mask */
0032 #define FAULT_TIMEOUT   (1<<0)
0033 #define FAULT_OVERTEMP  (1<<1)
0034 #define FAULT_SHORT_CIRCUIT (1<<2)
0035
0036 enum led_enable {
0037     MODE_SHDN = 0x0,
0038     MODE_TORCH = 0x2,
0039     MODE_FLASH = 0x3,
0040 };
0041
0042 /**
0043  * struct lm3560_flash
0044  *
0045  * @dev: pointer to &struct device
0046  * @pdata: platform data
0047  * @regmap: reg. map for i2c
0048  * @lock: muxtex for serial access.
0049  * @led_mode: V4L2 LED mode
0050  * @ctrls_led: V4L2 controls
0051  * @subdev_led: V4L2 subdev
0052  */
0053 struct lm3560_flash {
0054     struct device *dev;
0055     struct lm3560_platform_data *pdata;
0056     struct regmap *regmap;
0057     struct mutex lock;
0058
0059     enum v4l2_flash_led_mode led_mode;
0060     struct v4l2_ctrl_handler ctrls_led[LM3560_LED_MAX];
0061     struct v4l2_subdev subdev_led[LM3560_LED_MAX];
0062 };
0063
0064 #define to_lm3560_flash(_ctrl, _no) \
0065     container_of(_ctrl->handler, struct lm3560_flash, ctrls_led[_no])
0066
0067 /* enable mode control */
0068 static int lm3560_mode_ctrl(struct lm3560_flash *flash)
0069 {
0070     int rval = -EINVAL;
0071
0072     switch (flash->led_mode) {
0073     case V4L2_FLASH_LED_MODE_NONE:
0074         rval = regmap_update_bits(flash->regmap,
0075                       REG_ENABLE, 0x03, MODE_SHDN);
0076         break;
0077     case V4L2_FLASH_LED_MODE_TORCH:
0078         rval = regmap_update_bits(flash->regmap,
0079                       REG_ENABLE, 0x03, MODE_TORCH);
0080         break;
0081     case V4L2_FLASH_LED_MODE_FLASH:
0082         rval = regmap_update_bits(flash->regmap,
0083                       REG_ENABLE, 0x03, MODE_FLASH);
0084         break;
0085     }
0086     return rval;
0087 }
0088
0089 /* led1/2 enable/disable */
0090 static int lm3560_enable_ctrl(struct lm3560_flash *flash,
0091                   enum lm3560_led_id led_no, bool on)
0092 {
0093     int rval;
0094
0095     if (led_no == LM3560_LED0) {
0096         if (on)
0097             rval = regmap_update_bits(flash->regmap,
0098                           REG_ENABLE, 0x08, 0x08);
0099         else
0100             rval = regmap_update_bits(flash->regmap,
0101                           REG_ENABLE, 0x08, 0x00);
0102     } else {
0103         if (on)
0104             rval = regmap_update_bits(flash->regmap,
0105                           REG_ENABLE, 0x10, 0x10);
0106         else
0107             rval = regmap_update_bits(flash->regmap,
0108                           REG_ENABLE, 0x10, 0x00);
0109     }
0110     return rval;
0111 }
0112
0113 /* torch1/2 brightness control */
0114 static int lm3560_torch_brt_ctrl(struct lm3560_flash *flash,
0115                  enum lm3560_led_id led_no, unsigned int brt)
0116 {
0117     int rval;
0118     u8 br_bits;
0119
0120     if (brt < LM3560_TORCH_BRT_MIN)
0121         return lm3560_enable_ctrl(flash, led_no, false);
0122     else
0123         rval = lm3560_enable_ctrl(flash, led_no, true);
0124
0125     br_bits = LM3560_TORCH_BRT_uA_TO_REG(brt);
0126     if (led_no == LM3560_LED0)
0127         rval = regmap_update_bits(flash->regmap,
0128                       REG_TORCH_BR, 0x07, br_bits);
0129     else
0130         rval = regmap_update_bits(flash->regmap,
0131                       REG_TORCH_BR, 0x38, br_bits << 3);
0132
0133     return rval;
0134 }
0135
0136 /* flash1/2 brightness control */
0137 static int lm3560_flash_brt_ctrl(struct lm3560_flash *flash,
0138                  enum lm3560_led_id led_no, unsigned int brt)
0139 {
0140     int rval;
0141     u8 br_bits;
0142
0143     if (brt < LM3560_FLASH_BRT_MIN)
0144         return lm3560_enable_ctrl(flash, led_no, false);
0145     else
0146         rval = lm3560_enable_ctrl(flash, led_no, true);
0147
0148     br_bits = LM3560_FLASH_BRT_uA_TO_REG(brt);
0149     if (led_no == LM3560_LED0)
0150         rval = regmap_update_bits(flash->regmap,
0151                       REG_FLASH_BR, 0x0f, br_bits);
0152     else
0153         rval = regmap_update_bits(flash->regmap,
0154                       REG_FLASH_BR, 0xf0, br_bits << 4);
0155
0156     return rval;
0157 }
0158
0159 /* v4l2 controls  */
0160 static int lm3560_get_ctrl(struct v4l2_ctrl *ctrl, enum lm3560_led_id led_no)
0161 {
0162     struct lm3560_flash *flash = to_lm3560_flash(ctrl, led_no);
0163     int rval = -EINVAL;
0164
0165     mutex_lock(&flash->lock);
0166
0167     if (ctrl->id == V4L2_CID_FLASH_FAULT) {
0168         s32 fault = 0;
0169         unsigned int reg_val;
0170         rval = regmap_read(flash->regmap, REG_FLAG, &reg_val);
0171         if (rval < 0)
0172             goto out;
0173         if (reg_val & FAULT_SHORT_CIRCUIT)
0174             fault |= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
0175         if (reg_val & FAULT_OVERTEMP)
0176             fault |= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
0177         if (reg_val & FAULT_TIMEOUT)
0178             fault |= V4L2_FLASH_FAULT_TIMEOUT;
0179         ctrl->cur.val = fault;
0180     }
0181
0182 out:
0183     mutex_unlock(&flash->lock);
0184     return rval;
0185 }
0186
0187 static int lm3560_set_ctrl(struct v4l2_ctrl *ctrl, enum lm3560_led_id led_no)
0188 {
0189     struct lm3560_flash *flash = to_lm3560_flash(ctrl, led_no);
0190     u8 tout_bits;
0191     int rval = -EINVAL;
0192
0193     mutex_lock(&flash->lock);
0194
0195     switch (ctrl->id) {
0196     case V4L2_CID_FLASH_LED_MODE:
0197         flash->led_mode = ctrl->val;
0198         if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
0199             rval = lm3560_mode_ctrl(flash);
0200         break;
0201
0202     case V4L2_CID_FLASH_STROBE_SOURCE:
0203         rval = regmap_update_bits(flash->regmap,
0204                       REG_CONFIG1, 0x04, (ctrl->val) << 2);
0205         if (rval < 0)
0206             goto err_out;
0207         break;
0208
0209     case V4L2_CID_FLASH_STROBE:
0210         if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
0211             rval = -EBUSY;
0212             goto err_out;
0213         }
0214         flash->led_mode = V4L2_FLASH_LED_MODE_FLASH;
0215         rval = lm3560_mode_ctrl(flash);
0216         break;
0217
0218     case V4L2_CID_FLASH_STROBE_STOP:
0219         if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
0220             rval = -EBUSY;
0221             goto err_out;
0222         }
0223         flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
0224         rval = lm3560_mode_ctrl(flash);
0225         break;
0226
0227     case V4L2_CID_FLASH_TIMEOUT:
0228         tout_bits = LM3560_FLASH_TOUT_ms_TO_REG(ctrl->val);
0229         rval = regmap_update_bits(flash->regmap,
0230                       REG_FLASH_TOUT, 0x1f, tout_bits);
0231         break;
0232
0233     case V4L2_CID_FLASH_INTENSITY:
0234         rval = lm3560_flash_brt_ctrl(flash, led_no, ctrl->val);
0235         break;
0236
0237     case V4L2_CID_FLASH_TORCH_INTENSITY:
0238         rval = lm3560_torch_brt_ctrl(flash, led_no, ctrl->val);
0239         break;
0240     }
0241
0242 err_out:
0243     mutex_unlock(&flash->lock);
0244     return rval;
0245 }
0246
0247 static int lm3560_led1_get_ctrl(struct v4l2_ctrl *ctrl)
0248 {
0249     return lm3560_get_ctrl(ctrl, LM3560_LED1);
0250 }
0251
0252 static int lm3560_led1_set_ctrl(struct v4l2_ctrl *ctrl)
0253 {
0254     return lm3560_set_ctrl(ctrl, LM3560_LED1);
0255 }
0256
0257 static int lm3560_led0_get_ctrl(struct v4l2_ctrl *ctrl)
0258 {
0259     return lm3560_get_ctrl(ctrl, LM3560_LED0);
0260 }
0261
0262 static int lm3560_led0_set_ctrl(struct v4l2_ctrl *ctrl)
0263 {
0264     return lm3560_set_ctrl(ctrl, LM3560_LED0);
0265 }
0266
0267 static const struct v4l2_ctrl_ops lm3560_led_ctrl_ops[LM3560_LED_MAX] = {
0268     [LM3560_LED0] = {
0269              .g_volatile_ctrl = lm3560_led0_get_ctrl,
0270              .s_ctrl = lm3560_led0_set_ctrl,
0271              },
0272     [LM3560_LED1] = {
0273              .g_volatile_ctrl = lm3560_led1_get_ctrl,
0274              .s_ctrl = lm3560_led1_set_ctrl,
0275              }
0276 };
0277
0278 static int lm3560_init_controls(struct lm3560_flash *flash,
0279                 enum lm3560_led_id led_no)
0280 {
0281     struct v4l2_ctrl *fault;
0282     u32 max_flash_brt = flash->pdata->max_flash_brt[led_no];
0283     u32 max_torch_brt = flash->pdata->max_torch_brt[led_no];
0284     struct v4l2_ctrl_handler *hdl = &flash->ctrls_led[led_no];
0285     const struct v4l2_ctrl_ops *ops = &lm3560_led_ctrl_ops[led_no];
0286
0287     v4l2_ctrl_handler_init(hdl, 8);
0288
0289     /* flash mode */
0290     v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,
0291                    V4L2_FLASH_LED_MODE_TORCH, ~0x7,
0292                    V4L2_FLASH_LED_MODE_NONE);
0293     flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
0294
0295     /* flash source */
0296     v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_STROBE_SOURCE,
0297                    0x1, ~0x3, V4L2_FLASH_STROBE_SOURCE_SOFTWARE);
0298
0299     /* flash strobe */
0300     v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
0301
0302     /* flash strobe stop */
0303     v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
0304
0305     /* flash strobe timeout */
0306     v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TIMEOUT,
0307               LM3560_FLASH_TOUT_MIN,
0308               flash->pdata->max_flash_timeout,
0309               LM3560_FLASH_TOUT_STEP,
0310               flash->pdata->max_flash_timeout);
0311
0312     /* flash brt */
0313     v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_INTENSITY,
0314               LM3560_FLASH_BRT_MIN, max_flash_brt,
0315               LM3560_FLASH_BRT_STEP, max_flash_brt);
0316
0317     /* torch brt */
0318     v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TORCH_INTENSITY,
0319               LM3560_TORCH_BRT_MIN, max_torch_brt,
0320               LM3560_TORCH_BRT_STEP, max_torch_brt);
0321
0322     /* fault */
0323     fault = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_FAULT, 0,
0324                   V4L2_FLASH_FAULT_OVER_VOLTAGE
0325                   | V4L2_FLASH_FAULT_OVER_TEMPERATURE
0326                   | V4L2_FLASH_FAULT_SHORT_CIRCUIT
0327                   | V4L2_FLASH_FAULT_TIMEOUT, 0, 0);
0328     if (fault != NULL)
0329         fault->flags |= V4L2_CTRL_FLAG_VOLATILE;
0330
0331     if (hdl->error)
0332         return hdl->error;
0333
0334     flash->subdev_led[led_no].ctrl_handler = hdl;
0335     return 0;
0336 }
0337
0338 /* initialize device */
0339 static const struct v4l2_subdev_ops lm3560_ops = {
0340     .core = NULL,
0341 };
0342
0343 static const struct regmap_config lm3560_regmap = {
0344     .reg_bits = 8,
0345     .val_bits = 8,
0346     .max_register = 0xFF,
0347 };
0348
0349 static int lm3560_subdev_init(struct lm3560_flash *flash,
0350                   enum lm3560_led_id led_no, char *led_name)
0351 {
0352     struct i2c_client *client = to_i2c_client(flash->dev);
0353     int rval;
0354
0355     v4l2_i2c_subdev_init(&flash->subdev_led[led_no], client, &lm3560_ops);
0356     flash->subdev_led[led_no].flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
0357     strscpy(flash->subdev_led[led_no].name, led_name,
0358         sizeof(flash->subdev_led[led_no].name));
0359     rval = lm3560_init_controls(flash, led_no);
0360     if (rval)
0361         goto err_out;
0362     rval = media_entity_pads_init(&flash->subdev_led[led_no].entity, 0, NULL);
0363     if (rval < 0)
0364         goto err_out;
0365     flash->subdev_led[led_no].entity.function = MEDIA_ENT_F_FLASH;
0366
0367     return rval;
0368
0369 err_out:
0370     v4l2_ctrl_handler_free(&flash->ctrls_led[led_no]);
0371     return rval;
0372 }
0373
0374 static int lm3560_init_device(struct lm3560_flash *flash)
0375 {
0376     int rval;
0377     unsigned int reg_val;
0378
0379     /* set peak current */
0380     rval = regmap_update_bits(flash->regmap,
0381                   REG_FLASH_TOUT, 0x60, flash->pdata->peak);
0382     if (rval < 0)
0383         return rval;
0384     /* output disable */
0385     flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
0386     rval = lm3560_mode_ctrl(flash);
0387     if (rval < 0)
0388         return rval;
0389     /* reset faults */
0390     rval = regmap_read(flash->regmap, REG_FLAG, &reg_val);
0391     return rval;
0392 }
0393
0394 static int lm3560_probe(struct i2c_client *client,
0395             const struct i2c_device_id *devid)
0396 {
0397     struct lm3560_flash *flash;
0398     struct lm3560_platform_data *pdata = dev_get_platdata(&client->dev);
0399     int rval;
0400
0401     flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL);
0402     if (flash == NULL)
0403         return -ENOMEM;
0404
0405     flash->regmap = devm_regmap_init_i2c(client, &lm3560_regmap);
0406     if (IS_ERR(flash->regmap)) {
0407         rval = PTR_ERR(flash->regmap);
0408         return rval;
0409     }
0410
0411     /* if there is no platform data, use chip default value */
0412     if (pdata == NULL) {
0413         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
0414         if (pdata == NULL)
0415             return -ENODEV;
0416         pdata->peak = LM3560_PEAK_3600mA;
0417         pdata->max_flash_timeout = LM3560_FLASH_TOUT_MAX;
0418         /* led 1 */
0419         pdata->max_flash_brt[LM3560_LED0] = LM3560_FLASH_BRT_MAX;
0420         pdata->max_torch_brt[LM3560_LED0] = LM3560_TORCH_BRT_MAX;
0421         /* led 2 */
0422         pdata->max_flash_brt[LM3560_LED1] = LM3560_FLASH_BRT_MAX;
0423         pdata->max_torch_brt[LM3560_LED1] = LM3560_TORCH_BRT_MAX;
0424     }
0425     flash->pdata = pdata;
0426     flash->dev = &client->dev;
0427     mutex_init(&flash->lock);
0428
0429     rval = lm3560_subdev_init(flash, LM3560_LED0, "lm3560-led0");
0430     if (rval < 0)
0431         return rval;
0432
0433     rval = lm3560_subdev_init(flash, LM3560_LED1, "lm3560-led1");
0434     if (rval < 0)
0435         return rval;
0436
0437     rval = lm3560_init_device(flash);
0438     if (rval < 0)
0439         return rval;
0440
0441     i2c_set_clientdata(client, flash);
0442
0443     return 0;
0444 }
0445
0446 static int lm3560_remove(struct i2c_client *client)
0447 {
0448     struct lm3560_flash *flash = i2c_get_clientdata(client);
0449     unsigned int i;
0450
0451     for (i = LM3560_LED0; i < LM3560_LED_MAX; i++) {
0452         v4l2_device_unregister_subdev(&flash->subdev_led[i]);
0453         v4l2_ctrl_handler_free(&flash->ctrls_led[i]);
0454         media_entity_cleanup(&flash->subdev_led[i].entity);
0455     }
0456
0457     return 0;
0458 }
0459
0460 static const struct i2c_device_id lm3560_id_table[] = {
0461     {LM3559_NAME, 0},
0462     {LM3560_NAME, 0},
0463     {}
0464 };
0465
0466 MODULE_DEVICE_TABLE(i2c, lm3560_id_table);
0467
0468 static struct i2c_driver lm3560_i2c_driver = {
0469     .driver = {
0470            .name = LM3560_NAME,
0471            .pm = NULL,
0472            },
0473     .probe = lm3560_probe,
0474     .remove = lm3560_remove,
0475     .id_table = lm3560_id_table,
0476 };
0477
0478 module_i2c_driver(lm3560_i2c_driver);
0479
0480 MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
0481 MODULE_AUTHOR("Ldd Mlp <ldd-mlp@list.ti.com>");
0482 MODULE_DESCRIPTION("Texas Instruments LM3560 LED flash driver");
0483 MODULE_LICENSE("GPL");