drivers/media/i2c/dw9768.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2020 MediaTek Inc.
   3
   4 #include <linux/delay.h>
   5 #include <linux/i2c.h>
   6 #include <linux/module.h>
   7 #include <linux/pm_runtime.h>
   8 #include <linux/regulator/consumer.h>
   9 #include <media/v4l2-async.h>
  10 #include <media/v4l2-ctrls.h>
  11 #include <media/v4l2-device.h>
  12 #include <media/v4l2-fwnode.h>
  13 #include <media/v4l2-subdev.h>
  14
  15 #define DW9768_NAME                             "dw9768"
  16 #define DW9768_MAX_FOCUS_POS                    (1024 - 1)
  17 /*
  18  * This sets the minimum granularity for the focus positions.
  19  * A value of 1 gives maximum accuracy for a desired focus position
  20  */
  21 #define DW9768_FOCUS_STEPS                      1
  22
  23 /*
  24  * Ring control and Power control register
  25  * Bit[1] RING_EN
  26  * 0: Direct mode
  27  * 1: AAC mode (ringing control mode)
  28  * Bit[0] PD
  29  * 0: Normal operation mode
  30  * 1: Power down mode
  31  * DW9768 requires waiting time of Topr after PD reset takes place.
  32  */
  33 #define DW9768_RING_PD_CONTROL_REG              0x02
  34 #define DW9768_PD_MODE_OFF                      0x00
  35 #define DW9768_PD_MODE_EN                       BIT(0)
  36 #define DW9768_AAC_MODE_EN                      BIT(1)
  37
  38 /*
  39  * DW9768 separates two registers to control the VCM position.
  40  * One for MSB value, another is LSB value.
  41  * DAC_MSB: D[9:8] (ADD: 0x03)
  42  * DAC_LSB: D[7:0] (ADD: 0x04)
  43  * D[9:0] DAC data input: positive output current = D[9:0] / 1023 * 100[mA]
  44  */
  45 #define DW9768_MSB_ADDR                         0x03
  46 #define DW9768_LSB_ADDR                         0x04
  47 #define DW9768_STATUS_ADDR                      0x05
  48
  49 /*
  50  * AAC mode control & prescale register
  51  * Bit[7:5] Namely AC[2:0], decide the VCM mode and operation time.
  52  * 001 AAC2 0.48 x Tvib
  53  * 010 AAC3 0.70 x Tvib
  54  * 011 AAC4 0.75 x Tvib
  55  * 101 AAC8 1.13 x Tvib
  56  * Bit[2:0] Namely PRESC[2:0], set the internal clock dividing rate as follow.
  57  * 000 2
  58  * 001 1
  59  * 010 1/2
  60  * 011 1/4
  61  * 100 8
  62  * 101 4
  63  */
  64 #define DW9768_AAC_PRESC_REG                    0x06
  65 #define DW9768_AAC_MODE_SEL_MASK                GENMASK(7, 5)
  66 #define DW9768_CLOCK_PRE_SCALE_SEL_MASK         GENMASK(2, 0)
  67
  68 /*
  69  * VCM period of vibration register
  70  * Bit[5:0] Defined as VCM rising periodic time (Tvib) together with PRESC[2:0]
  71  * Tvib = (6.3ms + AACT[5:0] * 0.1ms) * Dividing Rate
  72  * Dividing Rate is the internal clock dividing rate that is defined at
  73  * PRESCALE register (ADD: 0x06)
  74  */
  75 #define DW9768_AAC_TIME_REG                     0x07
  76
  77 /*
  78  * DW9768 requires waiting time (delay time) of t_OPR after power-up,
  79  * or in the case of PD reset taking place.
  80  */
  81 #define DW9768_T_OPR_US                         1000
  82 #define DW9768_TVIB_MS_BASE10                   (64 - 1)
  83 #define DW9768_AAC_MODE_DEFAULT                 2
  84 #define DW9768_AAC_TIME_DEFAULT                 0x20
  85 #define DW9768_CLOCK_PRE_SCALE_DEFAULT          1
  86
  87 /*
  88  * This acts as the minimum granularity of lens movement.
  89  * Keep this value power of 2, so the control steps can be
  90  * uniformly adjusted for gradual lens movement, with desired
  91  * number of control steps.
  92  */
  93 #define DW9768_MOVE_STEPS                       16
  94
  95 static const char * const dw9768_supply_names[] = {
  96         "vin",  /* Digital I/O power */
  97         "vdd",  /* Digital core power */
  98 };
  99
 100 /* dw9768 device structure */
 101 struct dw9768 {
 102         struct regulator_bulk_data supplies[ARRAY_SIZE(dw9768_supply_names)];
 103         struct v4l2_ctrl_handler ctrls;
 104         struct v4l2_ctrl *focus;
 105         struct v4l2_subdev sd;
 106
 107         u32 aac_mode;
 108         u32 aac_timing;
 109         u32 clock_presc;
 110         u32 move_delay_us;
 111 };
 112
 113 static inline struct dw9768 *sd_to_dw9768(struct v4l2_subdev *subdev)
 114 {
 115         return container_of(subdev, struct dw9768, sd);
 116 }
 117
 118 struct regval_list {
 119         u8 reg_num;
 120         u8 value;
 121 };
 122
 123 struct dw9768_aac_mode_ot_multi {
 124         u32 aac_mode_enum;
 125         u32 ot_multi_base100;
 126 };
 127
 128 struct dw9768_clk_presc_dividing_rate {
 129         u32 clk_presc_enum;
 130         u32 dividing_rate_base100;
 131 };
 132
 133 static const struct dw9768_aac_mode_ot_multi aac_mode_ot_multi[] = {
 134         {1,  48},
 135         {2,  70},
 136         {3,  75},
 137         {5, 113},
 138 };
 139
 140 static const struct dw9768_clk_presc_dividing_rate presc_dividing_rate[] = {
 141         {0, 200},
 142         {1, 100},
 143         {2,  50},
 144         {3,  25},
 145         {4, 800},
 146         {5, 400},
 147 };
 148
 149 static u32 dw9768_find_ot_multi(u32 aac_mode_param)
 150 {
 151         u32 cur_ot_multi_base100 = 70;
 152         unsigned int i;
 153
 154         for (i = 0; i < ARRAY_SIZE(aac_mode_ot_multi); i++) {
 155                 if (aac_mode_ot_multi[i].aac_mode_enum == aac_mode_param) {
 156                         cur_ot_multi_base100 =
 157                                 aac_mode_ot_multi[i].ot_multi_base100;
 158                 }
 159         }
 160
 161         return cur_ot_multi_base100;
 162 }
 163
 164 static u32 dw9768_find_dividing_rate(u32 presc_param)
 165 {
 166         u32 cur_clk_dividing_rate_base100 = 100;
 167         unsigned int i;
 168
 169         for (i = 0; i < ARRAY_SIZE(presc_dividing_rate); i++) {
 170                 if (presc_dividing_rate[i].clk_presc_enum == presc_param) {
 171                         cur_clk_dividing_rate_base100 =
 172                                 presc_dividing_rate[i].dividing_rate_base100;
 173                 }
 174         }
 175
 176         return cur_clk_dividing_rate_base100;
 177 }
 178
 179 /*
 180  * DW9768_AAC_PRESC_REG & DW9768_AAC_TIME_REG determine VCM operation time.
 181  * For current VCM mode: AAC3, Operation Time would be 0.70 x Tvib.
 182  * Tvib = (6.3ms + AACT[5:0] * 0.1MS) * Dividing Rate.
 183  * Below is calculation of the operation delay for each step.
 184  */
 185 static inline u32 dw9768_cal_move_delay(u32 aac_mode_param, u32 presc_param,
 186                                         u32 aac_timing_param)
 187 {
 188         u32 Tvib_us;
 189         u32 ot_multi_base100;
 190         u32 clk_dividing_rate_base100;
 191
 192         ot_multi_base100 = dw9768_find_ot_multi(aac_mode_param);
 193
 194         clk_dividing_rate_base100 = dw9768_find_dividing_rate(presc_param);
 195
 196         Tvib_us = (DW9768_TVIB_MS_BASE10 + aac_timing_param) *
 197                   clk_dividing_rate_base100;
 198
 199         return Tvib_us * ot_multi_base100 / 100;
 200 }
 201
 202 static int dw9768_mod_reg(struct dw9768 *dw9768, u8 reg, u8 mask, u8 val)
 203 {
 204         struct i2c_client *client = v4l2_get_subdevdata(&dw9768->sd);
 205         int ret;
 206
 207         ret = i2c_smbus_read_byte_data(client, reg);
 208         if (ret < 0)
 209                 return ret;
 210
 211         val = ((unsigned char)ret & ~mask) | (val & mask);
 212
 213         return i2c_smbus_write_byte_data(client, reg, val);
 214 }
 215
 216 static int dw9768_set_dac(struct dw9768 *dw9768, u16 val)
 217 {
 218         struct i2c_client *client = v4l2_get_subdevdata(&dw9768->sd);
 219
 220         /* Write VCM position to registers */
 221         return i2c_smbus_write_word_swapped(client, DW9768_MSB_ADDR, val);
 222 }
 223
 224 static int dw9768_init(struct dw9768 *dw9768)
 225 {
 226         struct i2c_client *client = v4l2_get_subdevdata(&dw9768->sd);
 227         int ret, val;
 228
 229         /* Reset DW9768_RING_PD_CONTROL_REG to default status 0x00 */
 230         ret = i2c_smbus_write_byte_data(client, DW9768_RING_PD_CONTROL_REG,
 231                                         DW9768_PD_MODE_OFF);
 232         if (ret < 0)
 233                 return ret;
 234
 235         /*
 236          * DW9769 requires waiting delay time of t_OPR
 237          * after PD reset takes place.
 238          */
 239         usleep_range(DW9768_T_OPR_US, DW9768_T_OPR_US + 100);
 240
 241         /* Set DW9768_RING_PD_CONTROL_REG to DW9768_AAC_MODE_EN(0x01) */
 242         ret = i2c_smbus_write_byte_data(client, DW9768_RING_PD_CONTROL_REG,
 243                                         DW9768_AAC_MODE_EN);
 244         if (ret < 0)
 245                 return ret;
 246
 247         /* Set AAC mode */
 248         ret = dw9768_mod_reg(dw9768, DW9768_AAC_PRESC_REG,
 249                              DW9768_AAC_MODE_SEL_MASK,
 250                              dw9768->aac_mode << 5);
 251         if (ret < 0)
 252                 return ret;
 253
 254         /* Set clock presc */
 255         if (dw9768->clock_presc != DW9768_CLOCK_PRE_SCALE_DEFAULT) {
 256                 ret = dw9768_mod_reg(dw9768, DW9768_AAC_PRESC_REG,
 257                                      DW9768_CLOCK_PRE_SCALE_SEL_MASK,
 258                                      dw9768->clock_presc);
 259                 if (ret < 0)
 260                         return ret;
 261         }
 262
 263         /* Set AAC Timing */
 264         if (dw9768->aac_timing != DW9768_AAC_TIME_DEFAULT) {
 265                 ret = i2c_smbus_write_byte_data(client, DW9768_AAC_TIME_REG,
 266                                                 dw9768->aac_timing);
 267                 if (ret < 0)
 268                         return ret;
 269         }
 270
 271         for (val = dw9768->focus->val % DW9768_MOVE_STEPS;
 272              val <= dw9768->focus->val;
 273              val += DW9768_MOVE_STEPS) {
 274                 ret = dw9768_set_dac(dw9768, val);
 275                 if (ret) {
 276                         dev_err(&client->dev, "I2C failure: %d", ret);
 277                         return ret;
 278                 }
 279                 usleep_range(dw9768->move_delay_us,
 280                              dw9768->move_delay_us + 1000);
 281         }
 282
 283         return 0;
 284 }
 285
 286 static int dw9768_release(struct dw9768 *dw9768)
 287 {
 288         struct i2c_client *client = v4l2_get_subdevdata(&dw9768->sd);
 289         int ret, val;
 290
 291         val = round_down(dw9768->focus->val, DW9768_MOVE_STEPS);
 292         for ( ; val >= 0; val -= DW9768_MOVE_STEPS) {
 293                 ret = dw9768_set_dac(dw9768, val);
 294                 if (ret) {
 295                         dev_err(&client->dev, "I2C write fail: %d", ret);
 296                         return ret;
 297                 }
 298                 usleep_range(dw9768->move_delay_us,
 299                              dw9768->move_delay_us + 1000);
 300         }
 301
 302         ret = i2c_smbus_write_byte_data(client, DW9768_RING_PD_CONTROL_REG,
 303                                         DW9768_PD_MODE_EN);
 304         if (ret < 0)
 305                 return ret;
 306
 307         /*
 308          * DW9769 requires waiting delay time of t_OPR
 309          * after PD reset takes place.
 310          */
 311         usleep_range(DW9768_T_OPR_US, DW9768_T_OPR_US + 100);
 312
 313         return 0;
 314 }
 315
 316 static int dw9768_runtime_suspend(struct device *dev)
 317 {
 318         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 319         struct dw9768 *dw9768 = sd_to_dw9768(sd);
 320
 321         dw9768_release(dw9768);
 322         regulator_bulk_disable(ARRAY_SIZE(dw9768_supply_names),
 323                                dw9768->supplies);
 324
 325         return 0;
 326 }
 327
 328 static int dw9768_runtime_resume(struct device *dev)
 329 {
 330         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 331         struct dw9768 *dw9768 = sd_to_dw9768(sd);
 332         int ret;
 333
 334         ret = regulator_bulk_enable(ARRAY_SIZE(dw9768_supply_names),
 335                                     dw9768->supplies);
 336         if (ret < 0) {
 337                 dev_err(dev, "failed to enable regulators\n");
 338                 return ret;
 339         }
 340
 341         /*
 342          * The datasheet refers to t_OPR that needs to be waited before sending
 343          * I2C commands after power-up.
 344          */
 345         usleep_range(DW9768_T_OPR_US, DW9768_T_OPR_US + 100);
 346
 347         ret = dw9768_init(dw9768);
 348         if (ret < 0)
 349                 goto disable_regulator;
 350
 351         return 0;
 352
 353 disable_regulator:
 354         regulator_bulk_disable(ARRAY_SIZE(dw9768_supply_names),
 355                                dw9768->supplies);
 356
 357         return ret;
 358 }
 359
 360 static int dw9768_set_ctrl(struct v4l2_ctrl *ctrl)
 361 {
 362         struct dw9768 *dw9768 = container_of(ctrl->handler,
 363                                              struct dw9768, ctrls);
 364
 365         if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE)
 366                 return dw9768_set_dac(dw9768, ctrl->val);
 367
 368         return 0;
 369 }
 370
 371 static const struct v4l2_ctrl_ops dw9768_ctrl_ops = {
 372         .s_ctrl = dw9768_set_ctrl,
 373 };
 374
 375 static int dw9768_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 376 {
 377         return pm_runtime_resume_and_get(sd->dev);
 378 }
 379
 380 static int dw9768_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 381 {
 382         pm_runtime_put(sd->dev);
 383
 384         return 0;
 385 }
 386
 387 static const struct v4l2_subdev_internal_ops dw9768_int_ops = {
 388         .open = dw9768_open,
 389         .close = dw9768_close,
 390 };
 391
 392 static const struct v4l2_subdev_ops dw9768_ops = { };
 393
 394 static int dw9768_init_controls(struct dw9768 *dw9768)
 395 {
 396         struct v4l2_ctrl_handler *hdl = &dw9768->ctrls;
 397         const struct v4l2_ctrl_ops *ops = &dw9768_ctrl_ops;
 398
 399         v4l2_ctrl_handler_init(hdl, 1);
 400
 401         dw9768->focus = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FOCUS_ABSOLUTE, 0,
 402                                           DW9768_MAX_FOCUS_POS,
 403                                           DW9768_FOCUS_STEPS, 0);
 404
 405         if (hdl->error)
 406                 return hdl->error;
 407
 408         dw9768->sd.ctrl_handler = hdl;
 409
 410         return 0;
 411 }
 412
 413 static int dw9768_probe(struct i2c_client *client)
 414 {
 415         struct device *dev = &client->dev;
 416         struct dw9768 *dw9768;
 417         bool full_power;
 418         unsigned int i;
 419         int ret;
 420
 421         dw9768 = devm_kzalloc(dev, sizeof(*dw9768), GFP_KERNEL);
 422         if (!dw9768)
 423                 return -ENOMEM;
 424
 425         /* Initialize subdev */
 426         v4l2_i2c_subdev_init(&dw9768->sd, client, &dw9768_ops);
 427
 428         dw9768->aac_mode = DW9768_AAC_MODE_DEFAULT;
 429         dw9768->aac_timing = DW9768_AAC_TIME_DEFAULT;
 430         dw9768->clock_presc = DW9768_CLOCK_PRE_SCALE_DEFAULT;
 431
 432         /* Optional indication of AAC mode select */
 433         fwnode_property_read_u32(dev_fwnode(dev), "dongwoon,aac-mode",
 434                                  &dw9768->aac_mode);
 435
 436         /* Optional indication of clock pre-scale select */
 437         fwnode_property_read_u32(dev_fwnode(dev), "dongwoon,clock-presc",
 438                                  &dw9768->clock_presc);
 439
 440         /* Optional indication of AAC Timing */
 441         fwnode_property_read_u32(dev_fwnode(dev), "dongwoon,aac-timing",
 442                                  &dw9768->aac_timing);
 443
 444         dw9768->move_delay_us = dw9768_cal_move_delay(dw9768->aac_mode,
 445                                                       dw9768->clock_presc,
 446                                                       dw9768->aac_timing);
 447
 448         for (i = 0; i < ARRAY_SIZE(dw9768_supply_names); i++)
 449                 dw9768->supplies[i].supply = dw9768_supply_names[i];
 450
 451         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(dw9768_supply_names),
 452                                       dw9768->supplies);
 453         if (ret) {
 454                 dev_err(dev, "failed to get regulators\n");
 455                 return ret;
 456         }
 457
 458         /* Initialize controls */
 459         ret = dw9768_init_controls(dw9768);
 460         if (ret)
 461                 goto err_free_handler;
 462
 463         /* Initialize subdev */
 464         dw9768->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 465         dw9768->sd.internal_ops = &dw9768_int_ops;
 466
 467         ret = media_entity_pads_init(&dw9768->sd.entity, 0, NULL);
 468         if (ret < 0)
 469                 goto err_free_handler;
 470
 471         dw9768->sd.entity.function = MEDIA_ENT_F_LENS;
 472
 473         /*
 474          * Figure out whether we're going to power up the device here. Generally
 475          * this is done if CONFIG_PM is disabled in a DT system or the device is
 476          * to be powered on in an ACPI system. Similarly for power off in
 477          * remove.
 478          */
 479         pm_runtime_enable(dev);
 480         full_power = (is_acpi_node(dev_fwnode(dev)) &&
 481                       acpi_dev_state_d0(dev)) ||
 482                      (is_of_node(dev_fwnode(dev)) && !pm_runtime_enabled(dev));
 483         if (full_power) {
 484                 ret = dw9768_runtime_resume(dev);
 485                 if (ret < 0) {
 486                         dev_err(dev, "failed to power on: %d\n", ret);
 487                         goto err_clean_entity;
 488                 }
 489                 pm_runtime_set_active(dev);
 490         }
 491
 492         ret = v4l2_async_register_subdev(&dw9768->sd);
 493         if (ret < 0) {
 494                 dev_err(dev, "failed to register V4L2 subdev: %d", ret);
 495                 goto err_power_off;
 496         }
 497
 498         pm_runtime_idle(dev);
 499
 500         return 0;
 501
 502 err_power_off:
 503         if (full_power) {
 504                 dw9768_runtime_suspend(dev);
 505                 pm_runtime_set_suspended(dev);
 506         }
 507 err_clean_entity:
 508         pm_runtime_disable(dev);
 509         media_entity_cleanup(&dw9768->sd.entity);
 510 err_free_handler:
 511         v4l2_ctrl_handler_free(&dw9768->ctrls);
 512
 513         return ret;
 514 }
 515
 516 static void dw9768_remove(struct i2c_client *client)
 517 {
 518         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 519         struct dw9768 *dw9768 = sd_to_dw9768(sd);
 520         struct device *dev = &client->dev;
 521
 522         v4l2_async_unregister_subdev(&dw9768->sd);
 523         v4l2_ctrl_handler_free(&dw9768->ctrls);
 524         media_entity_cleanup(&dw9768->sd.entity);
 525         if ((is_acpi_node(dev_fwnode(dev)) && acpi_dev_state_d0(dev)) ||
 526             (is_of_node(dev_fwnode(dev)) && !pm_runtime_enabled(dev))) {
 527                 dw9768_runtime_suspend(dev);
 528                 pm_runtime_set_suspended(dev);
 529         }
 530         pm_runtime_disable(dev);
 531 }
 532
 533 static const struct of_device_id dw9768_of_table[] = {
 534         { .compatible = "dongwoon,dw9768" },
 535         { .compatible = "giantec,gt9769" },
 536         {}
 537 };
 538 MODULE_DEVICE_TABLE(of, dw9768_of_table);
 539
 540 static const struct dev_pm_ops dw9768_pm_ops = {
 541         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 542                                 pm_runtime_force_resume)
 543         SET_RUNTIME_PM_OPS(dw9768_runtime_suspend, dw9768_runtime_resume, NULL)
 544 };
 545
 546 static struct i2c_driver dw9768_i2c_driver = {
 547         .driver = {
 548                 .name = DW9768_NAME,
 549                 .pm = &dw9768_pm_ops,
 550                 .of_match_table = dw9768_of_table,
 551         },
 552         .probe_new  = dw9768_probe,
 553         .remove = dw9768_remove,
 554 };
 555 module_i2c_driver(dw9768_i2c_driver);
 556
 557 MODULE_AUTHOR("Dongchun Zhu <[email protected]>");
 558 MODULE_DESCRIPTION("DW9768 VCM driver");
 559 MODULE_LICENSE("GPL v2");