LM3644: Issue with Bulk Capacitor on OUT pin of IC - LM3644YFFR

Hanshraj Rajput

Part Number: LM3644

Tool/software:

Hello TI team,

We came across a query posted on the E2E forum regarding the adding of bulk capacitors at the C1-OUT pin of the IC- LM3644YFFR. You can find more details in the following link: LM3644: Is it safe to add bulk capacitance on OUT in mF range for pass-mode operation? - Power management forum - Power management - TI E2E support forums

In our design, we implemented a similar approach by adding a 1.82mF capacitor configuration (1x 1.5mF + 3x 100uF + 2x 10uF) at OUT pin and operated the system in pass mode. Unfortunately, we encountered an issue where no voltage was generated at the OUT pin, and the error on faults status "Vout_short = 1" was indicated. This problem seems to be caused by the adding of the bulk capacitor at the OUT pin.

Notably, when we removed the bulk capacitor from the OUT pin, the IC functioned as intended without any faults status.

Please let us know if you require any additional information from our side. We would appreciate your prompt response to help resolve this issue.

Regards,

Hanshraj Rajput

7 months ago

0 Andy Chen 7 months ago

TI__Mastermind 34875 points

Hi,

Did you check Vin and Vout with 1.8mF at startup? did you set current limit on input power source?

0 Hanshraj Rajput 7 months ago in reply to Andy Chen

Prodigy 50 points

Hello Andy,

Thankyou for your quick response.

1) Yes, we have checked Vin voltage its 3.89V , but Vout voltage is 0Volts.

2) Yes, we set the current limit on input voltage source to 500mA, but we did not observe voltage dips on input voltage rails, also we have checked by increase input source limit to 2A as well, but still observed same behavior.

We have also observe the IC goes to "standby" after a vout short gets reported.

Regards,

Hanshraj Rajput

0 Andy Chen 7 months ago in reply to Hanshraj Rajput

TI__Mastermind 34875 points

Hi Hanshraj,

Pls provide circuit schematic and program data for review.

0 Hanshraj Rajput 7 months ago in reply to Andy Chen

Prodigy 50 points

Hello Andy,

Please find attached source code and schematic screenshot.

Fullscreen ti-lm3644.c Download

#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>

#include "scandium-i2c-helpers.h"

#define AEV2_LM3644_ENABLE_ADDRESS 0x01
#define AEV2_LM3644_ENABLE_RESET_VALUE 0x80
#define AEV2_LM3644_ENABLE_LED1_ENABLE_SHIFT 0
#define AEV2_LM3644_ENABLE_LED1_ENABLE_WIDTH 1
#define AEV2_LM3644_ENABLE_LED1_ENABLE_OFF 0x0
#define AEV2_LM3644_ENABLE_LED1_ENABLE_ON 0x1
#define AEV2_LM3644_ENABLE_LED2_ENABLE_SHIFT 1
#define AEV2_LM3644_ENABLE_LED2_ENABLE_WIDTH 1
#define AEV2_LM3644_ENABLE_LED2_ENABLE_OFF 0x0
#define AEV2_LM3644_ENABLE_LED2_ENABLE_ON 0x1
#define AEV2_LM3644_ENABLE_MODE_SHIFT 2
#define AEV2_LM3644_ENABLE_MODE_WIDTH 2
#define AEV2_LM3644_ENABLE_MODE_STANDBY 0x0
#define AEV2_LM3644_ENABLE_MODE_IR_DRIVE 0x1
#define AEV2_LM3644_ENABLE_MODE_TORCH 0x2
#define AEV2_LM3644_ENABLE_MODE_FLASH 0x3
#define AEV2_LM3644_ENABLE_TORCH_TEMP_PIN_ENABLE_SHIFT 4
#define AEV2_LM3644_ENABLE_TORCH_TEMP_PIN_ENABLE_WIDTH 1
#define AEV2_LM3644_ENABLE_TORCH_TEMP_PIN_ENABLE_OFF 0x0
#define AEV2_LM3644_ENABLE_STROBE_ENABLE_SHIFT 5
#define AEV2_LM3644_ENABLE_STROBE_ENABLE_WIDTH 1
#define AEV2_LM3644_ENABLE_STROBE_ENABLE_OFF 0x0
#define AEV2_LM3644_ENABLE_STROBE_ENABLE_ON 0x1
#define AEV2_LM3644_ENABLE_STROBE_TYPE_SHIFT 6
#define AEV2_LM3644_ENABLE_STROBE_TYPE_WIDTH 1
#define AEV2_LM3644_ENABLE_STROBE_TYPE_LEVEL 0x0
#define AEV2_LM3644_ENABLE_TX_PIN_ENABLE_SHIFT 7
#define AEV2_LM3644_ENABLE_TX_PIN_ENABLE_WIDTH 1
#define AEV2_LM3644_ENABLE_TX_PIN_ENABLE_OFF 0x0

#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_ADDRESS 0x03
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_RESET_VALUE 0xBF
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_BRIGHTNESS_LEVEL_SHIFT 0
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_BRIGHTNESS_LEVEL_WIDTH 7
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_LED2_FLASH_CURRENT_OVERRIDE_SHIFT 7
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_LED2_FLASH_CURRENT_OVERRIDE_WIDTH 1
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_LED2_FLASH_CURRENT_OVERRIDE_NONE 0x0
#define AEV2_LM3644_LED1_FLASH_BRIGHTNESS_LED2_FLASH_CURRENT_OVERRIDE_SET_TO_LED1 0x1

#define AEV2_LM3644_LED2_FLASH_BRIGHTNESS_ADDRESS 0x04
#define AEV2_LM3644_LED2_FLASH_BRIGHTNESS_RESET_VALUE 0x3F
#define AEV2_LM3644_LED2_FLASH_BRIGHTNESS_BRIGHTNESS_LEVEL_SHIFT 0
#define AEV2_LM3644_LED2_FLASH_BRIGHTNESS_BRIGHTNESS_LEVEL_WIDTH 7

#define AEV2_LM3644_BOOST_CONFIGURATION_ADDRESS 0x07
#define AEV2_LM3644_BOOST_CONFIGURATION_RESET_VALUE 0x09
#define AEV2_LM3644_BOOST_CONFIGURATION_BOOST_MODE_SHIFT 2
#define AEV2_LM3644_BOOST_CONFIGURATION_BOOST_MODE_WIDTH 1
#define AEV2_LM3644_BOOST_CONFIGURATION_BOOST_MODE_NORMAL 0
#define AEV2_LM3644_BOOST_CONFIGURATION_BOOST_MODE_PASS_MODE_ONLY 1
#define AEV2_LM3644_BOOST_CONFIGURATION_LED_PIN_SHORT_FAULT_DETECT_SHIFT 3
#define AEV2_LM3644_BOOST_CONFIGURATION_LED_PIN_SHORT_FAULT_DETECT_WIDTH 1
#define AEV2_LM3644_BOOST_CONFIGURATION_LED_PIN_SHORT_FAULT_DETECT_DISABLED 0
#define AEV2_LM3644_BOOST_CONFIGURATION_LED_PIN_SHORT_FAULT_DETECT_ENABLED 1
#define AEV2_LM3644_BOOST_CONFIGURATION_SOFTWARE_RESET_BIT_SHIFT 7
#define AEV2_LM3644_BOOST_CONFIGURATION_SOFTWARE_RESET_BIT_WIDTH 1
#define AEV2_LM3644_BOOST_CONFIGURATION_SOFTWARE_RESET_BIT_NOT_RESET 0
#define AEV2_LM3644_BOOST_CONFIGURATION_SOFTWARE_RESET_BIT_RESET 1

#define AEV2_LM3644_TIMING_CONFIGURATION_ADDRESS 0x08
#define AEV2_LM3644_TIMING_CONFIGURATION_RESET_VALUE 0x1A
#define AEV2_LM3644_TIMING_CONFIGURATION_FLASH_TIMEOUT_DURATION_SHIFT 0
#define AEV2_LM3644_TIMING_CONFIGURATION_FLASH_TIMEOUT_DURATION_WIDTH 4

#define AEV2_LM3644_FLAGS1_ADDRESS 0x0A
#define AEV2_LM3644_FLAGS1_RESET_VALUE 0x00
#define AEV2_LM3644_FLAGS1_FLASH_TIMEOUT_SHIFT 0
#define AEV2_LM3644_FLAGS1_FLASH_TIMEOUT_WIDTH 1
#define AEV2_LM3644_FLAGS1_UVLO_SHIFT 1
#define AEV2_LM3644_FLAGS1_UVLO_WIDTH 1
#define AEV2_LM3644_FLAGS1_THERMAL_SHUTDOWN_SHIFT 2
#define AEV2_LM3644_FLAGS1_THERMAL_SHUTDOWN_WIDTH 1
#define AEV2_LM3644_FLAGS1_CURRENT_LIMIT_SHIFT 3
#define AEV2_LM3644_FLAGS1_CURRENT_LIMIT_WIDTH 1
#define AEV2_LM3644_FLAGS1_VLED2_SHORT_SHIFT 4
#define AEV2_LM3644_FLAGS1_VLED2_SHORT_WIDTH 1
#define AEV2_LM3644_FLAGS1_VLED1_SHORT_SHIFT 5
#define AEV2_LM3644_FLAGS1_VLED1_SHORT_WIDTH 1
#define AEV2_LM3644_FLAGS1_VOUT_SHORT_SHIFT 6
#define AEV2_LM3644_FLAGS1_VOUT_SHORT_WIDTH 1
#define AEV2_LM3644_FLAGS1_TX_SHIFT 7
#define AEV2_LM3644_FLAGS1_TX_WIDTH 1

#define AEV2_LM3644_FLAGS2_ADDRESS 0x0B
#define AEV2_LM3644_FLAGS2_RESET_VALUE 0x00
#define AEV2_LM3644_FLAGS2_TEMP_TRIP_SHIFT 0
#define AEV2_LM3644_FLAGS2_TEMP_TRIP_WIDTH 1
#define AEV2_LM3644_FLAGS2_OVP_SHIFT 1
#define AEV2_LM3644_FLAGS2_OVP_WIDTH 1
#define AEV2_LM3644_FLAGS2_IVFM_TRIP_SHIFT 2
#define AEV2_LM3644_FLAGS2_IVFM_TRIP_WIDTH 1
#define AEV2_LM3644_FLAGS2_NTC_OPEN_SHIFT 3
#define AEV2_LM3644_FLAGS2_NTC_OPEN_WIDTH 1
#define AEV2_LM3644_FLAGS2_NTC_SHORT_SHIFT 4
#define AEV2_LM3644_FLAGS2_NTC_SHORT_WIDTH 1

#define AEV2_LM3644_DEVICE_ID_ADDRESS 0x0C
#define AEV2_LM3644_DEVICE_ID_RESET_VALUE 0x02

static const struct of_device_id aev2_lm3644_of_match[] = {
	{ .compatible = "ti,lm3644", },
	{}
};

MODULE_DEVICE_TABLE(of, aev2_lm3644_of_match);


/*
 * Generic I2C helpers
 */

#define aev2_read_reg aev2_i2c_read_reg
#define aev2_write_reg aev2_i2c_write_reg 

#define AEV2_REGISTER(reg_name) AEV2_##reg_name##_ADDRESS


struct aev2_lm3644_state {
  struct i2c_client* client;
};

static int aev2_lm3644_state_init(struct aev2_lm3644_state* st,
				    struct i2c_client* client) {  
  st->client = client;

  return 0;
}

enum aev2_lm3644_mode {
		       AEV2_MODE_STANDBY,
		       AEV2_MODE_IR_DRIVE,
		       AEV2_MODE_TORCH,
		       AEV2_MODE_FLASH
};

static const char* aev2_lm3644_mode_to_str(enum aev2_lm3644_mode mode) {
  switch(mode) {
  case AEV2_MODE_STANDBY:
    return "standby";
  case AEV2_MODE_IR_DRIVE:
    return "ir_drive";
  case AEV2_MODE_TORCH:
    return "torch";
  case AEV2_MODE_FLASH:
    return "flash";
  }
  
  return NULL;
}

struct aev2_lm3644_faults {
  bool flash_timeout;
  bool uvlo_fault;
  bool thermal_shutdown_fault;
  bool current_limit_flag;
  bool vled2_short;
  bool vled1_short;
  bool vout_short;
  bool tx_flag;
  bool temp_trip;
  bool ovp_fault;
  bool ivfm_trip;
  bool ntc_open_fault;
  bool ntc_short_fault;
};

static int aev2_lm3644_get_faults(struct i2c_client* client, struct aev2_lm3644_faults* faults) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_FLAGS1, &val);
  if (ret) {
    dev_err(dev, "Failed to read the FLAGS1 register: %d\n", ret);
    return -EIO;
  }  
  faults->flash_timeout = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, FLASH_TIMEOUT, val);
  faults->uvlo_fault = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, UVLO, val);
  faults->thermal_shutdown_fault = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, THERMAL_SHUTDOWN, val);
  faults->current_limit_flag = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, CURRENT_LIMIT, val);
  faults->vled2_short = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, VLED2_SHORT, val);
  faults->vled1_short = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, VLED1_SHORT, val);
  faults->vout_short = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, VOUT_SHORT, val);
  faults->tx_flag = AEV2_PARSE_REG_FLAG(LM3644_FLAGS1, TX, val);

  ret = aev2_read_named_reg(client, LM3644_FLAGS2, &val);
  if (ret) {
    dev_err(dev, "Failed to read the FLAGS2 register: %d\n", ret);
    return -EIO;
  }
  faults->temp_trip = AEV2_PARSE_REG_FLAG(LM3644_FLAGS2, TEMP_TRIP, val);
  faults->ovp_fault = AEV2_PARSE_REG_FLAG(LM3644_FLAGS2, OVP, val);
  faults->ivfm_trip = AEV2_PARSE_REG_FLAG(LM3644_FLAGS2, IVFM_TRIP, val);
  faults->ntc_open_fault = AEV2_PARSE_REG_FLAG(LM3644_FLAGS2, NTC_OPEN, val);
  faults->ntc_short_fault = AEV2_PARSE_REG_FLAG(LM3644_FLAGS2, NTC_SHORT, val);

  return 0;
}

static int aev2_lm3644_get_mode(struct i2c_client* client, enum aev2_lm3644_mode* mode) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_ENABLE, &val);
  if (ret) {
    dev_err(dev, "Failed to read the ENABLE register: %d\n", ret);
    return -EIO;
  }

  val = AEV2_PARSE_REG_FLAG(LM3644_ENABLE, MODE, val);

  switch(val) {
  case AEV2_LM3644_ENABLE_MODE_STANDBY:
    *mode = AEV2_MODE_STANDBY;
    break;
  case AEV2_LM3644_ENABLE_MODE_IR_DRIVE:
    *mode = AEV2_MODE_IR_DRIVE;
    break;
  case AEV2_LM3644_ENABLE_MODE_TORCH:
    *mode = AEV2_MODE_TORCH;
    break;
  case AEV2_LM3644_ENABLE_MODE_FLASH:
    *mode = AEV2_MODE_FLASH;
    break;
  default:
    return -EINVAL;
  }
  
  return 0;
}

static int aev2_lm3644_set_mode(struct i2c_client* client, enum aev2_lm3644_mode mode) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;
  
  ret = aev2_read_named_reg(client, LM3644_ENABLE, &val);
  if (ret) {
    dev_err(dev, "Failed to read the ENABLE register: %d\n", ret);
    return -EIO;
  }

  switch (mode) {
  case AEV2_LM3644_ENABLE_MODE_STANDBY:
    val = AEV2_APPLY_REG_NAMED_FLAG(LM3644_ENABLE, val, MODE, STANDBY);
    break;
  case AEV2_LM3644_ENABLE_MODE_IR_DRIVE:
    val = AEV2_APPLY_REG_NAMED_FLAG(LM3644_ENABLE, val, MODE, IR_DRIVE);
    break;
  case AEV2_LM3644_ENABLE_MODE_TORCH:
    val = AEV2_APPLY_REG_NAMED_FLAG(LM3644_ENABLE, val, MODE, TORCH);
    break;
  case AEV2_LM3644_ENABLE_MODE_FLASH:
    val = AEV2_APPLY_REG_NAMED_FLAG(LM3644_ENABLE, val, MODE, FLASH);
    break;
  default:
    return -EINVAL;
  }

  ret = aev2_write_named_reg(client, LM3644_ENABLE, val);
  if (ret) {
    dev_err(dev, "Failed to write the ENABLE register: %d\n", ret);
    return ret;
  }

  return 0;
}

static int aev2_lm3644_get_strobe_enable(struct i2c_client* client, bool* strobe_en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_ENABLE, &val);
  if (ret) {
    dev_err(dev, "Failed to read the ENABLE register: %d\n", ret);
    return -EIO;
  }

  val = AEV2_PARSE_REG_FLAG(LM3644_ENABLE, STROBE_ENABLE, val);

  switch (val) {
  case AEV2_LM3644_ENABLE_STROBE_ENABLE_ON:   
    *strobe_en = true;
    break;
  case AEV2_LM3644_ENABLE_STROBE_ENABLE_OFF:
    *strobe_en = false;
    break;
  default:
    return -EINVAL;    
  }

  return 0;
}

static int aev2_lm3644_set_strobe_enable(struct i2c_client* client, bool strobe_en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;
  
  ret = aev2_read_named_reg(client, LM3644_ENABLE, &val);
  if (ret) {
    dev_err(dev, "Failed to read the ENABLE register: %d\n", ret);
    return -EIO;
  }

  if (strobe_en) {
    val = AEV2_APPLY_REG_NAMED_FLAG(LM3644_ENABLE, val, STROBE_ENABLE, ON);
  } else {
    val = AEV2_APPLY_REG_NAMED_FLAG(LM3644_ENABLE, val, STROBE_ENABLE, OFF);
  }

  ret = aev2_write_named_reg(client, LM3644_ENABLE, val);
  if (ret) {
    dev_err(dev, "Failed to write the ENABLE register: %d\n", ret);
    return ret;
  }
  
  return 0;
}

static int aev2_lm3644_get_led1_flash_brightness_level(struct i2c_client* client, int* level) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_LED1_FLASH_BRIGHTNESS, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LED1_FLASH_BRIGHTNESS register: %d\n", ret);
    return -EIO;
  }

  *level = AEV2_PARSE_REG_FLAG(LM3644_LED1_FLASH_BRIGHTNESS, BRIGHTNESS_LEVEL, val);

  return 0;
}

static int aev2_lm3644_set_led1_flash_brightness_level(struct i2c_client* client, int level) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  if (level < 0 || level >= (1<<AEV2_LM3644_LED1_FLASH_BRIGHTNESS_BRIGHTNESS_LEVEL_WIDTH)) {
    return -EINVAL;
  }
  
  ret = aev2_read_named_reg(client, LM3644_LED1_FLASH_BRIGHTNESS, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LED1_FLASH_BRIGHTNESS register: %d\n", ret);
    return -EIO;
  }

  ret = aev2_write_reg_from_flags1(client, LM3644_LED1_FLASH_BRIGHTNESS, BRIGHTNESS_LEVEL, level);
  if (ret) {
    dev_err(dev, "Failed to write the LED1_FLASH_BRIGHTNESS register: %d\n", ret);
    return ret;
  }
  
  return 0;
}

static int aev2_lm3644_get_flash_timeout_duration(struct i2c_client* client, int* timeout) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_TIMING_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_TIMING_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }

  *timeout = AEV2_PARSE_REG_FLAG(LM3644_TIMING_CONFIGURATION, FLASH_TIMEOUT_DURATION, val);

  return 0;
}

static int aev2_lm3644_set_flash_timeout_duration(struct i2c_client* client, int timeout) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  if (timeout < 0 || timeout >= (1<<AEV2_LM3644_TIMING_CONFIGURATION_FLASH_TIMEOUT_DURATION_WIDTH)) {
    return -EINVAL;
  }
  
  ret = aev2_read_named_reg(client, LM3644_TIMING_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_TIMING_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }

  ret = aev2_write_reg_from_flags1(client, LM3644_TIMING_CONFIGURATION, FLASH_TIMEOUT_DURATION, timeout);
  if (ret) {
    dev_err(dev, "Failed to write the LM3644_TIMING_CONFIGURATION register: %d\n", ret);
    return ret;
  }
  
  return 0;
}

static int aev2_lm3644_get_boost_mode(struct i2c_client* client, bool* en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_BOOST_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }

  switch (AEV2_PARSE_REG_FLAG(LM3644_BOOST_CONFIGURATION, BOOST_MODE, val)) {
  case AEV2_LM3644_BOOST_CONFIGURATION_BOOST_MODE_NORMAL:
    *en = true;
    break;
  case AEV2_LM3644_BOOST_CONFIGURATION_BOOST_MODE_PASS_MODE_ONLY:
    *en = false;
    break;
  default:
    return -EINVAL;
  }

  return 0;
}


static int aev2_lm3644_set_boost_mode(struct i2c_client* client, bool en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_BOOST_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }

  if (en) {
    ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, BOOST_MODE, NORMAL);
  } else {
    ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, BOOST_MODE, PASS_MODE_ONLY);
  }
  
  if (ret) {
    dev_err(dev, "Failed to write the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return ret;
  }
  
  return 0;
}


static int aev2_lm3644_get_led_pin_short_fault_detect(struct i2c_client* client, bool* en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_BOOST_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }
  
  switch (AEV2_PARSE_REG_FLAG(LM3644_BOOST_CONFIGURATION, LED_PIN_SHORT_FAULT_DETECT, val)) {
  case AEV2_LM3644_BOOST_CONFIGURATION_LED_PIN_SHORT_FAULT_DETECT_DISABLED:
    *en = false;
    break;
  case AEV2_LM3644_BOOST_CONFIGURATION_LED_PIN_SHORT_FAULT_DETECT_ENABLED:
    *en = true;
    break;
  default:
    return -EINVAL;
  }

  return 0;
}


static int aev2_lm3644_set_led_pin_short_fault_detect(struct i2c_client* client, bool en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_BOOST_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }

  if (en) {
    ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, LED_PIN_SHORT_FAULT_DETECT, ENABLED);
  } else {
    ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, LED_PIN_SHORT_FAULT_DETECT, DISABLED);
  }
  
  if (ret) {
    dev_err(dev, "Failed to write the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return ret;
  }
  
  return 0;
}

static int aev2_lm3644_get_software_reset_bit(struct i2c_client* client, bool* en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_BOOST_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }
  
  switch (AEV2_PARSE_REG_FLAG(LM3644_BOOST_CONFIGURATION, SOFTWARE_RESET_BIT, val)) {
  case AEV2_LM3644_BOOST_CONFIGURATION_SOFTWARE_RESET_BIT_NOT_RESET:
    *en = false;
    break;
  case AEV2_LM3644_BOOST_CONFIGURATION_SOFTWARE_RESET_BIT_RESET:
    *en = true;
    break;
  default:
    return -EINVAL;
  }

  return 0;
}

static int aev2_lm3644_set_software_reset_bit(struct i2c_client* client, bool en) {
  struct device* dev = &client->dev;
  int ret;
  u8 val;

  ret = aev2_read_named_reg(client, LM3644_BOOST_CONFIGURATION, &val);
  if (ret) {
    dev_err(dev, "Failed to read the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return -EIO;
  }

  if (en) {
    ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, SOFTWARE_RESET_BIT, RESET);
  } else {
    ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, SOFTWARE_RESET_BIT, NOT_RESET);
  }

  if (ret) {
    dev_err(dev, "Failed to write the LM3644_BOOST_CONFIGURATION register: %d\n", ret);
    return ret;
  }
  
  return 0;
}


/*
 * Sysfs
 */

static ssize_t aev2_lm3644_mode_show(struct device *dev,
	      struct device_attribute *attr, char *buf)
{
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  enum aev2_lm3644_mode mode;
  int ret = aev2_lm3644_get_mode(st->client, &mode);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%s\n", aev2_lm3644_mode_to_str(mode));
}

static ssize_t aev2_lm3644_mode_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int ret;
  
  if (strcmp(buf, "standby\n") == 0) {
    ret = aev2_lm3644_set_mode(st->client, AEV2_LM3644_ENABLE_MODE_STANDBY);
  } else if (strcmp(buf, "ir_drive\n") == 0) {
    ret = aev2_lm3644_set_mode(st->client, AEV2_LM3644_ENABLE_MODE_IR_DRIVE);
  } else if (strcmp(buf, "torch\n") == 0) {
    return -EOPNOTSUPP;
  } else if (strcmp(buf, "flash\n") == 0) {
    return -EOPNOTSUPP;
  } else {
    return -EINVAL;
  }	

  if (ret) {
    return ret;
  }
  
  return len;
}


static DEVICE_ATTR(mode, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_mode_show,
		   aev2_lm3644_mode_store);

static ssize_t aev2_lm3644_strobe_enable_show(struct device *dev,
	      struct device_attribute *attr, char *buf)
{
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  bool strobe_en;
  int ret = aev2_lm3644_get_strobe_enable(st->client, &strobe_en);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%d\n", strobe_en);
}

static ssize_t aev2_lm3644_strobe_enable_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int ret;
  
  if (strcmp(buf, "0\n") == 0) {
    ret = aev2_lm3644_set_strobe_enable(st->client, false);
  } else if (strcmp(buf, "1\n") == 0) {
    ret = aev2_lm3644_set_strobe_enable(st->client, true);
  } else {
    return -EINVAL;
  }	

  if (ret) {
    return ret;
  }
  
  return len;
}


static DEVICE_ATTR(strobe_enable, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_strobe_enable_show,
		   aev2_lm3644_strobe_enable_store);


static ssize_t aev2_lm3644_faults_show(struct device *dev,
					 struct device_attribute *attr, char *buf) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  struct i2c_client* client = st->client;
  struct aev2_lm3644_faults faults;
  int ret;
  
  ret = aev2_lm3644_get_faults(client, &faults);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf,
		  PAGE_SIZE,
		  "flash_timeout=%d, uvlo_fault=%d, thermal_shutdown_fault=%d, current_limit_flag=%d, vled2_short=%d, vled1_short=%d, vout_short=%d, tx_flag=%d, temp_trip=%d, ovp_fault=%d, ivfm_trip=%d, ntc_open_fault=%d, ntc_short_fault=%d\n",
		  faults.flash_timeout,
		  faults.uvlo_fault,
		  faults.thermal_shutdown_fault,
		  faults.current_limit_flag,
		  faults.vled2_short,
		  faults.vled1_short,
		  faults.vout_short,
		  faults.tx_flag,
		  faults.temp_trip,
		  faults.ovp_fault,
		  faults.ivfm_trip,
		  faults.ntc_open_fault,
		  faults.ntc_short_fault);
}

static DEVICE_ATTR(faults, S_IRUGO,
		   aev2_lm3644_faults_show,
		   NULL);


static ssize_t aev2_lm3644_led1_flash_brightness_level_show(struct device *dev,
	      struct device_attribute *attr, char *buf) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int led1_flash_brightness_level;
  int ret = aev2_lm3644_get_led1_flash_brightness_level(st->client, &led1_flash_brightness_level);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%d\n", led1_flash_brightness_level);
}

static ssize_t aev2_lm3644_led1_flash_brightness_level_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int led1_flash_brightness_level;
  int ret;
  
  ret = kstrtoint(buf, 10, &led1_flash_brightness_level);
  if (ret) {
    return -EINVAL;
  }

  ret = aev2_lm3644_set_led1_flash_brightness_level(st->client, led1_flash_brightness_level);
  if (ret) {
    return ret;
  }
  
  return len;
}

static DEVICE_ATTR(led1_flash_brightness_level, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_led1_flash_brightness_level_show,
		   aev2_lm3644_led1_flash_brightness_level_store);

static ssize_t aev2_lm3644_flash_timeout_duration_show(struct device *dev,
	      struct device_attribute *attr, char *buf) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int flash_timeout_duration;
  int ret = aev2_lm3644_get_flash_timeout_duration(st->client, &flash_timeout_duration);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%d\n", flash_timeout_duration);
}

static ssize_t aev2_lm3644_flash_timeout_duration_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int flash_timeout_duration;
  int ret;
  
  ret = kstrtoint(buf, 10, &flash_timeout_duration);
  if (ret) {
    return -EINVAL;
  }

  ret = aev2_lm3644_set_flash_timeout_duration(st->client, flash_timeout_duration);
  if (ret) {
    return ret;
  }
  
  return len;
}

static DEVICE_ATTR(flash_timeout_duration, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_flash_timeout_duration_show,
		   aev2_lm3644_flash_timeout_duration_store);



static ssize_t aev2_lm3644_boost_mode_show(struct device *dev,
	      struct device_attribute *attr, char *buf) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  bool boost_en;
  int ret = aev2_lm3644_get_boost_mode(st->client, &boost_en);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%s\n", boost_en ? "normal" : "pass_only");
}

static ssize_t aev2_lm3644_boost_mode_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int ret;
  
  if (strcmp(buf, "pass_only\n") == 0) {
    ret = aev2_lm3644_set_boost_mode(st->client, false);
  } else if (strcmp(buf, "normal\n") == 0) {
    ret = aev2_lm3644_set_boost_mode(st->client, true);
  } else {
    return -EINVAL;
  }

  if (ret) {
    return ret;
  }
  
  return len;
}

static DEVICE_ATTR(boost_mode, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_boost_mode_show,
		   aev2_lm3644_boost_mode_store);

static ssize_t aev2_lm3644_led_pin_short_fault_detect_show(struct device *dev,
	      struct device_attribute *attr, char *buf) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  bool detect_en;
  int ret = aev2_lm3644_get_led_pin_short_fault_detect(st->client, &detect_en);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%d\n", detect_en);
}

static ssize_t aev2_lm3644_led_pin_short_fault_detect_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int detect_en;
  int ret;
  
  ret = kstrtoint(buf, 10, &detect_en);
  if (ret) {
    return -EINVAL;
  }  
  if (detect_en == 0) {
    ret = aev2_lm3644_set_led_pin_short_fault_detect(st->client, false);
  } else if (detect_en == 1) {
    ret = aev2_lm3644_set_led_pin_short_fault_detect(st->client, true);
  } else {
    return -EINVAL;
  }

  if (ret) {
    return ret;
  }
  
  return len;
}

static DEVICE_ATTR(led_pin_short_fault_detect, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_led_pin_short_fault_detect_show,
		   aev2_lm3644_led_pin_short_fault_detect_store);

static ssize_t aev2_lm3644_software_reset_bit_show(struct device *dev,
	      struct device_attribute *attr, char *buf) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  bool reset_en;
  int ret = aev2_lm3644_get_software_reset_bit(st->client, &reset_en);
  if (ret) {
    return ret;
  }
  
  return snprintf(buf, PAGE_SIZE, "%d\n", reset_en);
}

static ssize_t aev2_lm3644_software_reset_bit_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t len) {
  struct aev2_lm3644_state* st = dev_get_drvdata(dev);
  int reset_en;
  int ret;
  
  ret = kstrtoint(buf, 10, &reset_en);
  if (ret) {
    return -EINVAL;
  }  
  if (reset_en == 0) {
    ret = aev2_lm3644_set_software_reset_bit(st->client, false);
  } else if (reset_en == 1) {
    ret = aev2_lm3644_set_software_reset_bit(st->client, true);
  } else {
    return -EINVAL;
  }

  if (ret) {
    return ret;
  }
  
  return len;
}


static DEVICE_ATTR(software_reset_bit, S_IRUGO  | S_IWUSR,
		   aev2_lm3644_software_reset_bit_show,
		   aev2_lm3644_software_reset_bit_store);


static int aev2_lm3644_check_device_id(struct i2c_client *client) {
  struct device* dev = &client->dev;
  u8 val;
  int ret;
  
  ret = aev2_read_named_reg(client, LM3644_DEVICE_ID, &val);
  if (ret) {
    dev_err(dev, "Failed to read the device ID register: %d\n", ret);
    return -EIO;
  }

  if (val != AEV2_LM3644_DEVICE_ID_RESET_VALUE) {
    dev_err(dev,
	    "Mismatching device ID; expected=0x%x, read=0x%x\n",
	    AEV2_LM3644_DEVICE_ID_RESET_VALUE,
	    val);
    return -ENODEV;
  }

  return 0;
}

static int aev2_lm3644_set_defconfig(struct i2c_client *client) {
  struct device* dev = &client->dev;  
  int ret;
  
  ret = aev2_write_reg_from_named_flags7(client, LM3644_ENABLE,
					 LED1_ENABLE, ON,
					 LED2_ENABLE, OFF,
					 MODE, IR_DRIVE,
					 TORCH_TEMP_PIN_ENABLE, OFF,
					 STROBE_ENABLE, OFF,
					 STROBE_TYPE, LEVEL,
					 TX_PIN_ENABLE, OFF);
  if (ret) {
    dev_err(dev, "Failed to set the ENABLE register: %d\n", ret);
    return ret;
  }				   

  
  ret = aev2_write_reg_from_named_flags1(client, LM3644_LED1_FLASH_BRIGHTNESS,
					 LED2_FLASH_CURRENT_OVERRIDE, NONE);
  if (ret) {
    dev_err(dev, "Failed to set the LED1_FLASH_BRIGHTNESS register: %d\n", ret);
    return ret;
  }				   

  /* Sets LED1 brightness to a safe default value: 5 * 11.725mA + 10.9 mA = 70 mA*/
  ret = aev2_write_reg_from_flags1(client, LM3644_LED2_FLASH_BRIGHTNESS, BRIGHTNESS_LEVEL, 5);
  if (ret) {
    dev_err(dev, "Failed to set the LED1_FLASH_BRIGHTNESS register: %d\n", ret);
    return ret;
  }				   
  
  /* LED2 management is unsupported: sets its brightness to the lowest value for safety. */
  ret = aev2_write_reg_from_flags1(client, LM3644_LED2_FLASH_BRIGHTNESS, BRIGHTNESS_LEVEL, 0);
  if (ret) {
    dev_err(dev, "Failed to set the LED2_FLASH_BRIGHTNESS register: %d\n", ret);
    return ret;
  }				   

  /* Sets the timout to the shortest duration (safety): level 0 = 10ms */
  ret = aev2_write_reg_from_flags1(client, LM3644_TIMING_CONFIGURATION, FLASH_TIMEOUT_DURATION, 0);
  if (ret) {
    dev_err(dev, "Failed to set the TIMING_CONFIGURATION register: %d\n", ret);
    return ret;
  }				   

  /* The scandium HW does not support boost mode */
  ret = aev2_write_reg_from_named_flags1(client, LM3644_BOOST_CONFIGURATION, BOOST_MODE, PASS_MODE_ONLY);
  if (ret) {
    dev_err(dev, "Failed to set the BOOST_CONFIGURATION register: %d\n", ret);
    return ret;
  }				   
  
  return 0;
}

/*
 * Module life time management
 */

static int aev2_lm3644_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
  struct device *dev = &client->dev;
  struct aev2_lm3644_state *st = devm_kzalloc(dev, sizeof(struct aev2_lm3644_state), GFP_KERNEL);
  int ret;

  dev_info(dev, "Probing LM3644");

  if (!st) {
    return -ENOMEM;
  }
      
  aev2_lm3644_state_init(st, client);  
  i2c_set_clientdata(client, st);

  ret = aev2_lm3644_check_device_id(client);
  if (ret) {
    return ret;
  }

  ret = aev2_lm3644_set_defconfig(client);
  if (ret) {
    return ret;
  }
  
  ret = device_create_file(dev, &dev_attr_faults);
  if (ret) {
    dev_err(dev, "Failed to create the 'faults' sysfs entry");
    return ret;
  }

  ret = device_create_file(dev, &dev_attr_mode);
  if (ret) {
    dev_err(dev, "Failed to create the 'mode' sysfs entry");
    goto remove_attr_faults;
  }

  ret = device_create_file(dev, &dev_attr_led1_flash_brightness_level);
  if (ret) {
    dev_err(dev, "Failed to create the 'led1_flash_brightness_level' sysfs entry");
    goto remove_attr_mode;
  }

  ret = device_create_file(dev, &dev_attr_flash_timeout_duration);
  if (ret) {
    dev_err(dev, "Failed to create the 'flash_timeout_duration' sysfs entry");
    goto remove_attr_led1_brightness_level;
  }
  
  ret = device_create_file(dev, &dev_attr_strobe_enable);
  if (ret) {
    dev_err(dev, "Failed to create the 'strobe_enable' sysfs entry");
    goto remove_attr_flash_timeout_duration;
  }

  ret = device_create_file(dev, &dev_attr_boost_mode);
  if (ret) {
    dev_err(dev, "Failed to create the 'boost_mode' sysfs entry");
    goto remove_attr_strobe_enable;
  }

  ret = device_create_file(dev, &dev_attr_led_pin_short_fault_detect);
  if (ret) {
    dev_err(dev, "Failed to create the 'led_pin_short_fault_detect' sysfs entry");
    goto remove_attr_boost_mode;
  }

  ret = device_create_file(dev, &dev_attr_software_reset_bit);
  if (ret) {
    dev_err(dev, "Failed to create the 'software_reset_bit' sysfs entry");
    goto remove_attr_led_pin_short_fault_detect;
  }
  
  
  dev_info(dev, "LM3644 probed successfully");
  return 0;

 remove_attr_flash_timeout_duration:
  device_remove_file(&client->dev, &dev_attr_flash_timeout_duration);
 remove_attr_led1_brightness_level:
  device_remove_file(&client->dev, &dev_attr_led1_flash_brightness_level);
 remove_attr_mode:
  device_remove_file(&client->dev, &dev_attr_mode);
 remove_attr_faults:
  device_remove_file(&client->dev, &dev_attr_faults);
 remove_attr_strobe_enable:
  device_remove_file(&client->dev, &dev_attr_strobe_enable);
 remove_attr_boost_mode:
  device_remove_file(&client->dev, &dev_attr_boost_mode);
 remove_attr_led_pin_short_fault_detect:
  device_remove_file(&client->dev, &dev_attr_led_pin_short_fault_detect);
  return ret;
}

static int aev2_lm3644_remove(struct i2c_client *client)
{
  struct device *dev = &client->dev;

  device_remove_file(&client->dev, &dev_attr_faults);
  device_remove_file(&client->dev, &dev_attr_mode);
  device_remove_file(&client->dev, &dev_attr_led1_flash_brightness_level);
  device_remove_file(&client->dev, &dev_attr_flash_timeout_duration);
  device_remove_file(&client->dev, &dev_attr_strobe_enable);
  device_remove_file(&client->dev, &dev_attr_boost_mode);
  device_remove_file(&client->dev, &dev_attr_led_pin_short_fault_detect);
  device_remove_file(&client->dev, &dev_attr_software_reset_bit);
  
  dev_info(dev, "LM3644 driver: bye!");
  return 0;
}

/* 
 * Module registration 
 */

static const struct i2c_device_id aev2_lm3644_id[] = {
	{"aev2_lm3644", 0},
	{}
};

static struct i2c_driver aev2_lm3644_i2c_driver = {
	.driver = {
		   .name = "7s_aev2_lm3644",
		   .owner = THIS_MODULE,
		   .of_match_table = of_match_ptr(aev2_lm3644_of_match),
		   },
	.probe = aev2_lm3644_probe,
	.remove = aev2_lm3644_remove,
	.id_table = aev2_lm3644_id,
};

module_i2c_driver(aev2_lm3644_i2c_driver);

Regards,

Hanshraj Rajput

0 Steven Li 7 months ago in reply to Hanshraj Rajput

TI__Mastermind 23190 points

Hi Hanshraj,

Our expert is currently out of office and will reply to you next Monday when back to office. Thanks for your understanding.

Best Regards,

Steven

0 Andy Chen 7 months ago in reply to Steven Li

TI__Mastermind 34875 points

Hi,

Circuit design looks OK,

Pls program the device in Pass Mode only.

Can you pls provide register data instead of the source code for review?

0 Hanshraj Rajput 6 months ago in reply to Andy Chen

Prodigy 50 points

Hello Andy,

Please find the attached register dump data as you requested, I hope this will be helpful for you.

- Register dump data before strobe signal enable:

- Register dump data after strobe signal enable:

Additionally, we have also tried by clearing the fault, but it does not help it go again and again in standby condition.

Regards,

Hanshraj Rajput

0 Hanshraj Rajput 6 months ago in reply to Hanshraj Rajput

Prodigy 50 points

Hello Andy,

Any update, I have already shared register dump data as you requested.

I hope you will understand priority to resolve this issue.

Regards,

Hanshraj Rajput

0 Andy Chen 6 months ago in reply to Hanshraj Rajput

TI__Mastermind 34875 points

Hi,

I'm check it with team, will update as early as possible.....

0 Hanshraj Rajput 6 months ago in reply to Andy Chen

Prodigy 50 points

Hello Andy,

When can we expect update on this issue?

If you need further any input from my side let me know.

Regards,

Hanshraj Rajput

0 Andy Chen 6 months ago in reply to Hanshraj Rajput

TI__Mastermind 34875 points

Hi,

in Boost mode or Pass mode if VOUT falls below 2.3 V, the device stops switching, and the PFET operates as a current source limiting the
current to 200 mA. and a deglitch time of 2.048 ms before the VOUT Short flag is valid.

So too big Cout 1.8mF makes VOUT can't ramp up to 2.3V within 2.03ms after power ON,

Can you put super cap on VIN pin and several tens of uF cap on VOUT pin?