示例#1
0
static int bcmpmu_i2c_write_device_direct_bulk(struct bcmpmu *bcmpmu, int map, int addr, unsigned int *val, int len)
{
	int err;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
	u8 *uval = (u8 *)val;
	int i;

	if (addr + len > acc->pagesize) return -ENODEV;

	for (i = 0; i < len; i++)
		uval[i] = (u8)val[i];


	bcmpmu_i2c_lock(acc);
	err = bcmpmu_i2c_retry(bcmpmu);
	if (err < 0)
		goto err;

	if (map == 0)
		err = i2c_smbus_write_i2c_block_data(acc->i2c_client, addr, len, uval);
	else if (map == 1)
		err = i2c_smbus_write_i2c_block_data(acc->i2c_client1, addr, len, uval);
	else err = -EIO;
	last_i2c_trans = I2C_TRANS_WRITE;
	bcmpmu_i2c_unlock(acc);
err:
	if (err < 0) return err;
	return 0;
}
示例#2
0
static int bcmpmu_i2c_pwrmgr_read_direct(struct bcmpmu *bcmpmu,
					 int map, int addr,
					 unsigned int *val,
					 unsigned int msk)
{
	int err = 0;
	u8 temp;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
	if ((addr == 0) && (msk == 0))
		return -ENODEV;

	bcmpmu_i2c_lock(acc);

	pr_debug("%s\n", __func__);

	if (map == 0)
		err = i2c_try_read_write(bcmpmu, I2C_TRANS_READ,
				addr, acc->i2c_client->addr, &temp);
	else if (map == 1)
		err = i2c_try_read_write(bcmpmu, I2C_TRANS_READ,
				addr, acc->i2c_client1->addr, &temp);
	else
		err = -EIO;

	if (err < 0)
		goto out_unlock;

	temp &= msk;
	*val = temp;
out_unlock:
	bcmpmu_i2c_unlock(acc);
	return err;

}
static int bcmpmu_i2c_read_device_direct_bulk(struct bcmpmu *bcmpmu, int map,
					      int addr, unsigned int *val,
					      int len)
{
	int err;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
	u8 *uval = (u8 *) val;
	int i;

	if (addr + len > acc->pagesize)
		return -ENODEV;

	bcmpmu_i2c_lock(acc);
	if (map == 0)
		err =
		    i2c_smbus_read_i2c_block_data(acc->i2c_client, addr, len,
						  uval);
	else if (map == 1)
		err =
		    i2c_smbus_read_i2c_block_data(acc->i2c_client1, addr, len,
						  uval);
	else
		err = -EIO;
	bcmpmu_i2c_unlock(acc);

	for (i = len; i > 0; i--)
		val[i - 1] = (unsigned int)uval[i - 1];

	if (err < 0)
		return err;
	return 0;
}
示例#4
0
static int bcmpmu_i2c_write_device_direct(struct bcmpmu *bcmpmu, int map, int addr, unsigned int val, unsigned int msk)
{
	int err;
	u8 value = (u8)val;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
	if ((addr == 0) && (msk == 0))  return -ENODEV;

	bcmpmu_i2c_lock(acc);
	err = bcmpmu_i2c_retry(bcmpmu);
	if (err < 0)
		goto err;

	if (map == 0)
		err = i2c_smbus_read_byte_data(acc->i2c_client, addr);
	else if (map == 1)
		err = i2c_smbus_read_byte_data(acc->i2c_client1, addr);
	else err = -EIO;
	if (err < 0) goto err;

	err = err & ~msk;
	value = value | err;

	if (map == 0)
		err = i2c_smbus_write_byte_data(acc->i2c_client, addr, value);
	else if (map == 1)
		err = i2c_smbus_write_byte_data(acc->i2c_client1, addr, value);
	else err = -EIO;
	last_i2c_trans = I2C_TRANS_WRITE;
err:
	bcmpmu_i2c_unlock(acc);
	return err;
}
示例#5
0
static int bcmpmu_i2c_read_device(struct bcmpmu *bcmpmu, int reg, unsigned int *val, unsigned int msk)
{
	struct bcmpmu_reg_map map;
	int err;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;

	if (reg >= PMU_REG_MAX) return -ENODEV;
	map = bcmpmu->regmap[reg];
	if ((map.addr == 0) && (map.mask == 0))  return -ENXIO;

	bcmpmu_i2c_lock(acc);
	err = bcmpmu_i2c_retry(bcmpmu);
	if (err < 0)
		goto err;
	if (map.map == 0)
		err = i2c_smbus_read_byte_data(acc->i2c_client, map.addr);
	else if (map.map == 1)
		err = i2c_smbus_read_byte_data(acc->i2c_client1, map.addr);
	else err = -EIO;
	last_i2c_trans = I2C_TRANS_READ;
	bcmpmu_i2c_unlock(acc);
err:
	if (err < 0) return err;
	err = err & msk;
	err = err & map.mask;
	*val = err;

	return 0;
}
static int bcmpmu_i2c_pwrmgr_write(struct bcmpmu59xxx *bcmpmu, u32 reg, u8 val)
{
	int ret = 0;
	bcmpmu_i2c_lock(bcmpmu);
	ret = bcmpmu_i2c_try_write(bcmpmu, reg, val);
	bcmpmu_i2c_unlock(bcmpmu);
	pr_pmui2c(DATA, "WR done reg %x val %x\n", reg, val);
	return ret;
}
static int bcmpmu_i2c_pwrmgr_read(struct bcmpmu59xxx *bcmpmu, u32 reg, u8 * val)
{
	int ret;
	if (!bcmpmu || !val)
		return -EINVAL;

	bcmpmu_i2c_lock(bcmpmu);
	ret = bcmpmu_i2c_try_read(bcmpmu, reg, val);
	bcmpmu_i2c_unlock(bcmpmu);
	pr_pmui2c(DATA, "RD done reg %x val %x\n", reg, *val);
	return ret;
}
static int bcmpmu_i2c_pwrmgr_write(struct bcmpmu *bcmpmu, int reg,
				   unsigned int value, unsigned int msk)
{
	struct bcmpmu_reg_map map;
	int err = 0;
	u8 temp;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;

	if (reg >= PMU_REG_MAX)
		return -ENODEV;

	map = bcmpmu->regmap[reg];
	if ((map.addr == 0) && (map.mask == 0))
		return -ENXIO;

	bcmpmu_i2c_lock(acc);

	pr_debug("%s\n", __func__);

	if (map.map == 0)
		err = i2c_try_read_write(bcmpmu, true, I2C_TRANS_READ, map.addr,
					 acc->i2c_client->addr, &temp);
	else if (map.map == 1)
		err = i2c_try_read_write(bcmpmu, true, I2C_TRANS_READ, map.addr,
					 acc->i2c_client1->addr, &temp);
	else
		err = -EIO;

	if (err < 0)
		goto out_unlock;

	temp &= ~msk;
	temp &= ~map.mask;
	temp |= (u8) value;

	if (map.map == 0)
		err = i2c_try_read_write(bcmpmu, true, I2C_TRANS_WRITE,
								map.addr,
					 acc->i2c_client->addr, &temp);
	else if (map.map == 1)
		err = i2c_try_read_write(bcmpmu, true, I2C_TRANS_WRITE,
								map.addr,
					 acc->i2c_client1->addr, &temp);
	else
		err = -ENODEV;
      out_unlock:
	bcmpmu_i2c_unlock(acc);
	return err;
}
static int bcmpmu_i2c_read_device_direct_bulk(struct bcmpmu59xxx *bcmpmu,
					      u32 reg, u8 *val, int len)
{
	int err = 0;
	struct i2c_client *clt;

	if ((DEC_REG_ADD(reg) + len) >= PMU_REG_MAX)
		return -ENODEV;
	clt = bcmpmu_get_client(bcmpmu, reg);

	bcmpmu_i2c_lock(bcmpmu);
	err =
	    i2c_smbus_read_i2c_block_data(clt, (u8) DEC_REG_ADD(reg), len, val);
	bcmpmu_i2c_unlock(bcmpmu);
	return (err < 0 ? err : 0);
}
static int bcmpmu_i2c_write_device(struct bcmpmu59xxx *bcmpmu, u32 reg,
				   u8 value)
{
	int err;
	struct i2c_client *clt;

	if (DEC_REG_ADD(reg) >= PMU_REG_MAX)
		return -ENODEV;

	clt = bcmpmu_get_client(bcmpmu, reg);

	bcmpmu_i2c_lock(bcmpmu);
	err = i2c_smbus_write_byte_data(clt, (u8) DEC_REG_ADD(reg), value);
	bcmpmu_i2c_unlock(bcmpmu);
	return (err < 0 ? err : 0);
}
/* Return Error codes in i2c read/write interfaces
 *-ENODEV = if wrong register has been passed
 *-ENXIO = if register exists but no map found
 *-EIO = i2c read/write error
*/
static int bcmpmu_i2c_read_device(struct bcmpmu59xxx *bcmpmu, u32 reg, u8 *val)
{
	int err;
	struct i2c_client *clt;

	if (DEC_REG_ADD(reg) >= PMU_REG_MAX)
		return -ENODEV;
	clt = bcmpmu_get_client(bcmpmu, reg);

	bcmpmu_i2c_lock(bcmpmu);
	err = i2c_smbus_read_byte_data(clt, (u8) DEC_REG_ADD(reg));
	bcmpmu_i2c_unlock(bcmpmu);
	if (err < 0)
		return err;
	*val = err;
	return 0;
}
static int bcmpmu_i2c_pwrmgr_write_bulk(struct bcmpmu59xxx *bcmpmu,
					u32 reg, u8 *val, int len)
{
	int err = 0;
	int i;
	u8 temp;

	bcmpmu_i2c_lock(bcmpmu);
	for (i = 0; i < len; i++) {
		temp = val[i];
		err = bcmpmu_i2c_try_write(bcmpmu, reg + i, temp);
		if (err < 0)
			break;
	}
	bcmpmu_i2c_unlock(bcmpmu);
	return err;
}
static int bcmpmu_i2c_pwrmgr_read_bulk(struct bcmpmu59xxx *bcmpmu,
				       u32 reg, u8 *val, int len)
{
	int err = 0;
	int i;
	u8 temp = 0;

	bcmpmu_i2c_lock(bcmpmu);
	for (i = 0; i < len; i++) {
		err = bcmpmu_i2c_try_read(bcmpmu, reg + i, &temp);
		if (err < 0)
			break;
		val[i] = temp;
	}
	bcmpmu_i2c_unlock(bcmpmu);
	return err;
}
static int bcmpmu_i2c_write_device(struct bcmpmu *bcmpmu, int reg,
				   unsigned int value, unsigned int msk)
{
	struct bcmpmu_reg_map map;
	int err;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;

	if (reg >= PMU_REG_MAX)
		return -ENODEV;
	map = bcmpmu->regmap[reg];
	if ((map.addr == 0) && (map.mask == 0))
		return -ENXIO;

	bcmpmu_i2c_lock(acc);
	if (map.map == 0)
		err = i2c_smbus_read_byte_data(acc->i2c_client, map.addr);
	else if (map.map == 1)
		err = i2c_smbus_read_byte_data(acc->i2c_client1, map.addr);
	else
		err = -EIO;
	if (err < 0)
		goto err;

	err = err & ~msk;
	err = err & ~map.mask;
	value = value | err;

	if (map.map == 0)
		err =
		    i2c_smbus_write_byte_data(acc->i2c_client, map.addr, value);
	else if (map.map == 1)
		err =
		    i2c_smbus_write_byte_data(acc->i2c_client1, map.addr,
					      value);
	else
		err = -EIO;
      err:
	bcmpmu_i2c_unlock(acc);
	return err;
}
示例#15
0
static int bcmpmu_i2c_pwrmgr_write_direct_bulk(struct bcmpmu *bcmpmu,
					       int map, int addr,
					       unsigned int *val,
					       int len)
{
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
	int err = 0;
	int i;
	u8 temp;

	if (addr + len > acc->pagesize)
		return -ENODEV;

	if ((map != 0) && (map != 1))
		return -EIO;

	bcmpmu_i2c_lock(acc);

	pr_debug("%s\n", __func__);

	for (i = 0; i < len; i++) {
		temp = val[i];

		if (map == 0)
			err = i2c_try_read_write(bcmpmu, I2C_TRANS_WRITE,
					addr + i, acc->i2c_client->addr,
					&temp);
		else
			err = i2c_try_read_write(bcmpmu, I2C_TRANS_WRITE,
					addr + i, acc->i2c_client1->addr,
					&temp);
		if (err < 0)
			break;
	}

	bcmpmu_i2c_unlock(acc);
	return err;
}
示例#16
0
static int bcmpmu_i2c_read_device_direct(struct bcmpmu *bcmpmu, int map, int addr, unsigned int *val, unsigned int msk)
{
	int err;
	struct bcmpmu_i2c *acc = (struct bcmpmu_i2c *)bcmpmu->accinfo;
	if ((addr == 0) && (msk == 0))  return -ENODEV;

	bcmpmu_i2c_lock(acc);
	err = bcmpmu_i2c_retry(bcmpmu);
	if (err < 0)
		goto err;

	if (map == 0)
		err = i2c_smbus_read_byte_data(acc->i2c_client, addr);
	else if (map == 1)
		err = i2c_smbus_read_byte_data(acc->i2c_client1, addr);
	else err = -EIO;
	last_i2c_trans = I2C_TRANS_READ;
	bcmpmu_i2c_unlock(acc);
err:
	if (err < 0) return err;
	err = err & msk;
	*val = err;
	return 0;
}