xref: /OK3568_Linux_fs/kernel/drivers/gpu/drm/rockchip/ebc-dev/pmic/tps65185.c (revision 4882a59341e53eb6f0b4789bf948001014eff981)

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
 *
 * Author: Zorro Liu <zorro.liu@rock-chips.com>
 */

#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/major.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/version.h>
#include <linux/suspend.h>
#include <linux/soc/rockchip/rk_vendor_storage.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include "ebc_pmic.h"

/* After waking up from sleep, Papyrus
   waits for VN to be discharged and all
   voltage ref to startup before loading
   the default EEPROM settings. So accessing
   registers too early after WAKEUP could
   cause the register to be overridden by
   default values */
#define PAPYRUS_EEPROM_DELAY_MS 50
/* Papyrus WAKEUP pin must stay low for
   a minimum time */
#define PAPYRUS_SLEEP_MINIMUM_MS 110
/* Temp sensor might take a little time to
   settle eventhough the status bit in TMST1
   state conversion is done - if read too early
   0C will be returned instead of the right temp */
#define PAPYRUS_TEMP_READ_TIME_MS 10
/* Powerup sequence takes at least 24 ms - no need to poll too frequently */
#define HW_GET_STATE_INTERVAL_MS 24

#define SEQ_VDD(index)		((index % 4) << 6)
#define SEQ_VPOS(index)	((index % 4) << 4)
#define SEQ_VEE(index)		((index % 4) << 2)
#define SEQ_VNEG(index)	((index % 4) << 0)

/* power up seq delay time */
#define UDLY_3ms(index)	(0x00 << ((index%4) * 2))
#define UDLY_6ms(index)	(0x01 << ((index%4) * 2))
#define UDLY_9ms(index)	(0x10 << ((index%4) * 2))
#define UDLY_12ms(index)	(0x11 << ((index%4) * 2))

/* power down seq delay time */
#define DDLY_6ms(index)	(0x00 << ((index%4) * 2))
#define DDLY_12ms(index)	(0x01 << ((index%4) * 2))
#define DDLY_24ms(index)	(0x10 << ((index%4) * 2))
#define DDLY_48ms(index)	(0x11 << ((index%4) * 2))

#define NUMBER_PMIC_REGS	10

#define PAPYRUS_ADDR_TMST_VALUE	0x00
#define PAPYRUS_ADDR_ENABLE			0x01
#define PAPYRUS_ADDR_VADJ			0x02
#define PAPYRUS_ADDR_VCOM1_ADJUST	0x03
#define PAPYRUS_ADDR_VCOM2_ADJUST	0x04
#define PAPYRUS_ADDR_INT_ENABLE1	0x05
#define PAPYRUS_ADDR_INT_ENABLE2	0x06
#define PAPYRUS_ADDR_INT_STATUS1	0x07
#define PAPYRUS_ADDR_INT_STATUS2	0x08
#define PAPYRUS_ADDR_UPSEQ0			0x09
#define PAPYRUS_ADDR_UPSEQ1			0x0a
#define PAPYRUS_ADDR_DWNSEQ0		0x0b
#define PAPYRUS_ADDR_DWNSEQ1		0x0c
#define PAPYRUS_ADDR_TMST1			0x0d
#define PAPYRUS_ADDR_TMST2			0x0e
#define PAPYRUS_ADDR_PG_STATUS		0x0f
#define PAPYRUS_ADDR_REVID			0x10

// INT_ENABLE1
#define PAPYRUS_INT_ENABLE1_ACQC_EN	1
#define PAPYRUS_INT_ENABLE1_PRGC_EN		0

// INT_STATUS1
#define PAPYRUS_INT_STATUS1_ACQC		1
#define PAPYRUS_INT_STATUS1_PRGC		0

// VCOM2_ADJUST
#define PAPYRUS_VCOM2_ACQ		7
#define PAPYRUS_VCOM2_PROG		6
#define PAPYRUS_VCOM2_HIZ		5

#define PAPYRUS_MV_TO_VCOMREG(MV)	((MV) / 10)

#define V3P3_EN_MASK		0x20
#define PAPYRUS_V3P3OFF_DELAY_MS	20//100

struct papyrus_sess {
	struct device *dev;
	struct i2c_client *client;
	uint8_t enable_reg_shadow;
	uint8_t vadj;
	uint8_t vcom1;
	uint8_t vcom2;
	uint8_t upseq0;
	uint8_t upseq1;
	uint8_t dwnseq0;
	uint8_t dwnseq1;
	int irq;
	struct gpio_desc *int_pin;
	struct gpio_desc *pwr_en_pin;
	struct gpio_desc *pwr_up_pin;
	struct gpio_desc *wake_up_pin;
	struct gpio_desc *vcom_ctl_pin;
	struct mutex power_lock;
	struct workqueue_struct *tmp_monitor_wq;
	struct delayed_work tmp_delay_work;
};

struct papyrus_hw_state {
	uint8_t tmst_value;
	uint8_t int_status1;
	uint8_t int_status2;
	uint8_t pg_status;
};
static bool papyrus_need_reconfig = true;

static int papyrus_hw_setreg(struct papyrus_sess *sess, uint8_t regaddr, uint8_t val)
{
	int stat;
	uint8_t txbuf[2] = { regaddr, val };
	struct i2c_msg msgs[] = {
		{
			.addr = sess->client->addr,
			.flags = 0,
			.len = 2,
			.buf = txbuf,
		}
	};

	stat = i2c_transfer(sess->client->adapter, msgs, ARRAY_SIZE(msgs));

	if (stat < 0) {
		dev_err(&sess->client->dev, "i2c send error: %d\n", stat);
	} else if (stat != ARRAY_SIZE(msgs)) {
		dev_err(&sess->client->dev, "i2c send N mismatch: %d\n", stat);
		stat = -EIO;
	} else {
		stat = 0;
	}

	return stat;
}

static int papyrus_hw_getreg(struct papyrus_sess *sess, uint8_t regaddr, uint8_t *val)
{
	int stat;
	struct i2c_msg msgs[] = {
		{
			.addr = sess->client->addr,
			.flags = 0,
			.len = 1,
			.buf = &regaddr,
		},
		{
			.addr = sess->client->addr,
			.flags = I2C_M_RD,
			.len = 1,
			.buf = val,
		}
	};

	stat = i2c_transfer(sess->client->adapter, msgs, ARRAY_SIZE(msgs));
	if (stat < 0) {
		dev_err(&sess->client->dev, "i2c read error: %d\n", stat);
	} else if (stat != ARRAY_SIZE(msgs)) {
		dev_err(&sess->client->dev, "i2c read N mismatch: %d\n", stat);
		stat = -EIO;
	} else {
		stat = 0;
	}

	return stat;
}

static void papyrus_hw_get_int_state(struct papyrus_sess *sess, struct papyrus_hw_state *hwst)
{
	int stat;

	stat = papyrus_hw_getreg(sess, PAPYRUS_ADDR_INT_STATUS1, &hwst->int_status1);
	if (stat)
		dev_err(&sess->client->dev, "i2c error: %d\n", stat);

	stat = papyrus_hw_getreg(sess, PAPYRUS_ADDR_INT_STATUS2, &hwst->int_status2);
	if (stat)
		dev_err(&sess->client->dev, "i2c error: %d\n", stat);
}
#if 0
static bool papyrus_hw_power_ack(struct papyrus_sess *sess, int up)
{
	struct papyrus_hw_state hwst;
	int st;
	int retries_left = 10;

	if ((up & ~(1UL))) {
		dev_err(&sess->client->dev, "invalid power flag %d.\n", up);
		return false;
	}

	do {
		papyrus_hw_getreg(sess, PAPYRUS_ADDR_PG_STATUS, &hwst.pg_status);
		dev_dbg(&sess->client->dev, "hwst: tmst_val=%d, ist1=%02x, ist2=%02x, pg=%02x\n",
			hwst.tmst_value, hwst.int_status1, hwst.int_status2, hwst.pg_status);
		hwst.pg_status &= 0xfa;
		if ((hwst.pg_status == 0xfa) && (up == 1)) {
			st = 1;
		} else if ((hwst.pg_status == 0x00) && (up == 0)) {
			st = 0;
		} else {
			st = -1;	/* not settled yet */
			msleep(HW_GET_STATE_INTERVAL_MS);
		}
		retries_left--;
	} while ((st == -1) && retries_left);

	if (st == -1)
		dev_err(&sess->client->dev, "power %s settle error (PG = %02x)\n", up ? "up" : "down", hwst.pg_status);

	return (st == up);
}
#endif
static void papyrus_hw_send_powerup(struct papyrus_sess *sess)
{
	int stat = 0;

	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_VADJ, sess->vadj);

	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_UPSEQ0, sess->upseq0);
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_UPSEQ1, sess->upseq1);
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_DWNSEQ0, sess->dwnseq0);
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_DWNSEQ1, sess->dwnseq1);

	//stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_VCOM1_ADJUST, sess->vcom1);
	//stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_VCOM2_ADJUST, sess->vcom2);

	sess->enable_reg_shadow |= V3P3_EN_MASK;
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_ENABLE, sess->enable_reg_shadow);
	usleep_range(2 * 1000, 3 * 1000);

	sess->enable_reg_shadow = (0x80 | 0x30 | 0x0F);
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_ENABLE, sess->enable_reg_shadow);
	if (stat)
		dev_err(&sess->client->dev, "i2c error: %d\n", stat);
	if (!IS_ERR_OR_NULL(sess->pwr_up_pin))
		gpiod_direction_output(sess->pwr_up_pin, 1);

	return;
}

static void papyrus_hw_send_powerdown(struct papyrus_sess *sess)
{
	int stat = 0;

	sess->enable_reg_shadow = (0x40 | 0x20 | 0x0F);
	stat = papyrus_hw_setreg(sess, PAPYRUS_ADDR_ENABLE, sess->enable_reg_shadow);
	usleep_range(2 * 1000, 3 * 1000);
	sess->enable_reg_shadow &= ~V3P3_EN_MASK;
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_ENABLE, sess->enable_reg_shadow);
	if (stat)
		dev_err(&sess->client->dev, "i2c error: %d\n", stat);


	return;
}

static irqreturn_t papyrus_irq(int irq, void *dev_id)
{
	struct papyrus_sess *sess = dev_id;
	struct papyrus_hw_state hwst;

	papyrus_hw_get_int_state(sess, &hwst);
	dev_info(&sess->client->dev, "%s: (INT1 = %02x, INT2 = %02x)\n", __func__,
						hwst.int_status1, hwst.int_status2);
	//reset pmic
	if ((hwst.int_status2 & 0xfa) || (hwst.int_status1 & 0x04)) {
		if (sess->enable_reg_shadow | V3P3_EN_MASK)
			papyrus_hw_setreg(sess, PAPYRUS_ADDR_ENABLE, sess->enable_reg_shadow);
	}

	return IRQ_HANDLED;
}

static int papyrus_hw_get_revid(struct papyrus_sess *sess)
{
	int stat;
	uint8_t revid;

	stat = papyrus_hw_getreg(sess, PAPYRUS_ADDR_REVID, &revid);
	if (stat) {
		dev_err(&sess->client->dev, "i2c error: %d\n", stat);
		return stat;
	} else {
		return revid;
	}
}

static void papyrus_hw_arg_init(struct papyrus_sess *sess)
{
	sess->vadj = 0x03;
	sess->upseq0 = SEQ_VEE(0) | SEQ_VNEG(1) | SEQ_VPOS(2) | SEQ_VDD(3);
	sess->upseq1 = UDLY_3ms(0) | UDLY_3ms(1) | UDLY_3ms(2) | UDLY_3ms(3);
	sess->dwnseq0 = SEQ_VDD(0) | SEQ_VPOS(1) | SEQ_VNEG(2) | SEQ_VEE(3);
	sess->dwnseq1 = DDLY_6ms(0) | DDLY_6ms(1) | DDLY_6ms(2) | DDLY_6ms(3);
	sess->vcom1 = (PAPYRUS_MV_TO_VCOMREG(1560) & 0x00FF);
	sess->vcom2 = ((PAPYRUS_MV_TO_VCOMREG(1560) & 0x0100) >> 8);
}

static int papyrus_hw_init(struct papyrus_sess *sess)
{
	int stat = 0;

	if (!IS_ERR_OR_NULL(sess->pwr_en_pin)) {
		gpiod_direction_output(sess->pwr_en_pin, 1);
		usleep_range(2 * 1000, 3 * 1000);
	}
	gpiod_direction_output(sess->wake_up_pin, 0);
	/* wait to reset papyrus */
	msleep(PAPYRUS_SLEEP_MINIMUM_MS);
	gpiod_direction_output(sess->wake_up_pin, 1);
	/* power up pin no need to control, use i2c control */
	if (!IS_ERR_OR_NULL(sess->pwr_up_pin))
		gpiod_direction_output(sess->pwr_up_pin, 0);
	gpiod_direction_output(sess->vcom_ctl_pin, 1);
	msleep(PAPYRUS_EEPROM_DELAY_MS);

	stat = papyrus_hw_get_revid(sess);
	if (stat < 0) {
		dev_err(&sess->client->dev, "get id failed");
		return stat;
	}

	dev_info(&sess->client->dev, "detected device with ID=%02x (TPS6518%dr%dp%d)\n",
		 stat, stat & 0xF, (stat & 0xC0) >> 6, (stat & 0x30) >> 4);

	return 0;
}

static void papyrus_set_vcom_voltage(struct papyrus_sess *sess, int vcom_mv)
{
	sess->vcom1 = (PAPYRUS_MV_TO_VCOMREG(vcom_mv) & 0x00FF);
	sess->vcom2 = ((PAPYRUS_MV_TO_VCOMREG(vcom_mv) & 0x0100) >> 8);
}

static int papyrus_hw_read_temperature(struct ebc_pmic *pmic, int *t)
{
	struct papyrus_sess *sess = (struct papyrus_sess *)pmic->drvpar;
	int stat;
	uint8_t tb;
#if 0
	int ntries = 50;

	stat = papyrus_hw_setreg(sess, PAPYRUS_ADDR_TMST1, 0x80);
	if (stat)
		return stat;
	do {
		stat = papyrus_hw_getreg(sess, PAPYRUS_ADDR_TMST1, &tb);
	} while (!stat && ntries-- && (((tb & 0x20) == 0) || (tb & 0x80)));

	if (stat)
		return stat;

	msleep(PAPYRUS_TEMP_READ_TIME_MS);
#endif
	stat = papyrus_hw_getreg(sess, PAPYRUS_ADDR_TMST_VALUE, &tb);
	*t = (int)(int8_t)tb;

	return stat;
}

static void papyrus_hw_power_req(struct ebc_pmic *pmic, bool up)
{
	struct papyrus_sess *sess = (struct papyrus_sess *)pmic->drvpar;

	if (up)
		mutex_lock(&sess->power_lock);
	if (papyrus_need_reconfig) {
		if (up) {
			papyrus_hw_send_powerup(sess);
			//papyrus_hw_power_ack(sess, up);
			enable_irq(sess->irq);
		} else {
			disable_irq(sess->irq);
			papyrus_hw_send_powerdown(sess);
			//papyrus_hw_power_ack(sess, up);
		}
		papyrus_need_reconfig = false;
	} else {
		if (up) {
			if (!IS_ERR_OR_NULL(sess->pwr_up_pin))
				gpiod_direction_output(sess->pwr_up_pin, 1);
			enable_irq(sess->irq);
		} else {
			disable_irq(sess->irq);
			if (!IS_ERR_OR_NULL(sess->pwr_up_pin))
				gpiod_direction_output(sess->pwr_up_pin, 0);
		}
	}
	if (!up)
		mutex_unlock(&sess->power_lock);
	return;
}

static int papyrus_hw_vcom_get(struct ebc_pmic *pmic)
{
	struct papyrus_sess *sess = (struct papyrus_sess *)pmic->drvpar;
	uint8_t rev_val = 0;
	int stat = 0;
	int read_vcom_mv = 0;

	mutex_lock(&sess->power_lock);
	// VERIFICATION
	gpiod_direction_output(sess->wake_up_pin, 0);
	msleep(10);
	gpiod_direction_output(sess->wake_up_pin, 1);
	msleep(10);
	read_vcom_mv = 0;
	stat |= papyrus_hw_getreg(sess, PAPYRUS_ADDR_VCOM1_ADJUST, &rev_val);
	read_vcom_mv += rev_val;
	stat |= papyrus_hw_getreg(sess, PAPYRUS_ADDR_VCOM2_ADJUST, &rev_val);
	read_vcom_mv += ((rev_val & 0x0001) << 8);

	if (stat)
		dev_err(&sess->client->dev, "papyrus: I2C error: %d\n", stat);
	mutex_unlock(&sess->power_lock);

	return read_vcom_mv * 10;
}

static int papyrus_hw_vcom_set(struct ebc_pmic *pmic, int vcom_mv)
{
	struct papyrus_sess *sess = (struct papyrus_sess *)pmic->drvpar;
	uint8_t rev_val = 0;
	int stat = 0;

	mutex_lock(&sess->power_lock);
	gpiod_direction_output(sess->wake_up_pin, 1);
	msleep(10);
	// Set vcom voltage
	papyrus_set_vcom_voltage(sess, vcom_mv);
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_VCOM1_ADJUST, sess->vcom1);
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_VCOM2_ADJUST, sess->vcom2);

	// PROGRAMMING
	sess->vcom2 |= 1 << PAPYRUS_VCOM2_PROG;
	stat |= papyrus_hw_setreg(sess, PAPYRUS_ADDR_VCOM2_ADJUST, sess->vcom2);
	rev_val = 0;
	while (!(rev_val & (1 << PAPYRUS_INT_STATUS1_PRGC))) {
		stat |= papyrus_hw_getreg(sess, PAPYRUS_ADDR_INT_STATUS1, &rev_val);
		if (stat)
			break;
		msleep(50);
	}

	if (stat)
		dev_err(&sess->client->dev, "papyrus: I2C error: %d\n", stat);
	mutex_unlock(&sess->power_lock);

	return 0;
}

static void papyrus_pm_sleep(struct ebc_pmic *pmic)
{
	struct papyrus_sess *s = (struct papyrus_sess *)pmic->drvpar;

	cancel_delayed_work_sync(&s->tmp_delay_work);

	mutex_lock(&s->power_lock);
	gpiod_direction_output(s->vcom_ctl_pin, 0);
	gpiod_direction_output(s->wake_up_pin, 0);
	if (!IS_ERR_OR_NULL(s->pwr_en_pin))
		gpiod_direction_output(s->pwr_en_pin, 0);
	papyrus_need_reconfig = true;
	mutex_unlock(&s->power_lock);
}

static void papyrus_pm_resume(struct ebc_pmic *pmic)
{
	struct papyrus_sess *s = (struct papyrus_sess *)pmic->drvpar;

	mutex_lock(&s->power_lock);
	if (!IS_ERR_OR_NULL(s->pwr_en_pin)) {
		gpiod_direction_output(s->pwr_en_pin, 1);
		usleep_range(2 * 1000, 3 * 1000);
	}
	gpiod_direction_output(s->wake_up_pin, 1);
	gpiod_direction_output(s->vcom_ctl_pin, 1);
	usleep_range(2 * 1000, 3 * 1000);
	mutex_unlock(&s->power_lock);

	//trigger temperature measurement
	papyrus_hw_setreg(s, PAPYRUS_ADDR_TMST1, 0x80);
	queue_delayed_work(s->tmp_monitor_wq, &s->tmp_delay_work,
			   msecs_to_jiffies(10000));
}

static void papyrus_tmp_work(struct work_struct *work)
{
	struct papyrus_sess *s =
		container_of(work, struct papyrus_sess, tmp_delay_work.work);

	//trigger temperature measurement
	papyrus_hw_setreg(s, PAPYRUS_ADDR_TMST1, 0x80);

	queue_delayed_work(s->tmp_monitor_wq, &s->tmp_delay_work,
			   msecs_to_jiffies(10000));
}

static int papyrus_probe(struct ebc_pmic *pmic, struct i2c_client *client)
{
	struct papyrus_sess *sess;
	int stat;

	sess = devm_kzalloc(&client->dev, sizeof(*sess), GFP_KERNEL);
	if (!sess) {
		dev_err(&client->dev, "%s:%d: kzalloc failed\n", __func__, __LINE__);
		return -ENOMEM;
	}
	sess->client = client;
	mutex_init(&sess->power_lock);
	papyrus_hw_arg_init(sess);

	sess->pwr_en_pin = devm_gpiod_get_optional(&client->dev, "poweren", GPIOD_OUT_HIGH);
	if (IS_ERR_OR_NULL(sess->pwr_en_pin)) {
		dev_err(&client->dev, "tsp65185: failed to find poweren pin, no defined\n");
	}

	sess->wake_up_pin = devm_gpiod_get_optional(&client->dev, "wakeup", GPIOD_OUT_HIGH);
	if (IS_ERR_OR_NULL(sess->wake_up_pin)) {
		dev_err(&client->dev, "tsp65185: failed to find wakeup pin\n");
		return -ENOMEM;
	}

	sess->vcom_ctl_pin = devm_gpiod_get_optional(&client->dev, "vcomctl", GPIOD_OUT_HIGH);
	if (IS_ERR_OR_NULL(sess->vcom_ctl_pin)) {
		dev_err(&client->dev, "tsp65185: failed to find vcom_ctl pin\n");
		return -ENOMEM;
	}

	sess->pwr_up_pin = devm_gpiod_get_optional(&client->dev, "powerup", GPIOD_OUT_HIGH);
	if (IS_ERR_OR_NULL(sess->pwr_up_pin))
		dev_err(&client->dev, "tsp65185: no pwr_up pin find\n");

	sess->int_pin = devm_gpiod_get(&client->dev, "int", GPIOD_IN);
	if (IS_ERR(sess->int_pin)) {
		dev_err(&client->dev, "tsp65185: failed to find int pin\n");
		return PTR_ERR(sess->int_pin);
	}
	sess->irq = gpiod_to_irq(sess->int_pin);
	if (sess->irq < 0) {
		dev_err(&client->dev, "Unable to get irq number for int pin\n");
		return sess->irq;
	}

	irq_set_status_flags(sess->irq, IRQ_NOAUTOEN);
	stat = devm_request_threaded_irq(&client->dev, sess->irq, NULL, papyrus_irq,
					IRQF_TRIGGER_LOW | IRQF_ONESHOT,
					"tps65185", sess);
	if (stat) {
		dev_err(&client->dev,
			"Failed to enable IRQ, error: %d\n", stat);
		return stat;
	}

	sess->tmp_monitor_wq = alloc_ordered_workqueue("%s",
			WQ_MEM_RECLAIM | WQ_FREEZABLE, "tps-tmp-monitor-wq");
	INIT_DELAYED_WORK(&sess->tmp_delay_work, papyrus_tmp_work);
	queue_delayed_work(sess->tmp_monitor_wq, &sess->tmp_delay_work,
			   msecs_to_jiffies(10000));

	stat = papyrus_hw_init(sess);
	if (stat)
		return stat;

	sess->enable_reg_shadow = 0;
	stat = papyrus_hw_setreg(sess, PAPYRUS_ADDR_ENABLE, sess->enable_reg_shadow);
	if (stat)
		return stat;

	//trigger temperature measurement
	papyrus_hw_setreg(sess, PAPYRUS_ADDR_TMST1, 0x80);

	pmic->drvpar = sess;

	pmic->pmic_get_vcom = papyrus_hw_vcom_get;
	pmic->pmic_set_vcom = papyrus_hw_vcom_set;
	pmic->pmic_pm_resume = papyrus_pm_resume;
	pmic->pmic_pm_suspend = papyrus_pm_sleep;
	pmic->pmic_power_req = papyrus_hw_power_req;
	pmic->pmic_read_temperature = papyrus_hw_read_temperature;

	return 0;
}

static int tps65185_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct ebc_pmic *pmic;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		dev_err(&client->dev, "i2c check functionality failed.");
		return -ENODEV;
	}

	pmic = devm_kzalloc(&client->dev, sizeof(*pmic), GFP_KERNEL);
	if (!pmic) {
		dev_err(&client->dev, "%s:%d: kzalloc failed\n", __func__, __LINE__);
		return -ENOMEM;
	}

	if (0 != papyrus_probe(pmic, client)) {
		dev_err(&client->dev, "tps65185 hw init failed.");
		return -ENODEV;
	}

	pmic->dev = &client->dev;
	sprintf(pmic->pmic_name, "tps65185");
	i2c_set_clientdata(client, pmic);

	dev_info(&client->dev, "tps65185 probe ok.\n");

	return 0;
}

static int tps65185_remove(struct i2c_client *client)
{
	return 0;
}

static const struct i2c_device_id tps65185_id[] = {
	{ "tps65185", 0 },
	{ }
};

static const struct of_device_id tps65185_dt_ids[] = {
	{ .compatible = "ti,tps65185", },
	{ /* sentinel */ }
};

MODULE_DEVICE_TABLE(of, tps65185_dt_ids);
static struct i2c_driver tps65185_driver = {
	.probe	= tps65185_probe,
	.remove 	= tps65185_remove,
	.id_table	= tps65185_id,
	.driver = {
		.of_match_table = tps65185_dt_ids,
		.name	  = "tps65185",
		.owner	  = THIS_MODULE,
	},
};

module_i2c_driver(tps65185_driver);

MODULE_DESCRIPTION("ti tps65185 pmic");
MODULE_LICENSE("GPL");