Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4d5e3790 authored by Gilad Avidov's avatar Gilad Avidov Committed by Michael Bohan
Browse files

i2c-msm-v2: Suport for long ptr and rid of pdata 



Remove dependency on platfrom data which is declared
on the no longer exists arch/arm directory. Support for
longer pointers.

Change-Id: I453284211cb701f2e3f065f41652d8aaba571f08
Signed-off-by: default avatarGilad Avidov <gavidov@codeaurora.org>
parent 2606fcbd

arch/arm/mach-msm/include/mach/i2c-msm.h

deleted100644 → 0
+0 −48
Original line number Diff line number Diff line 
/* Copyright (c) 2013, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

/*

 * I2C driver for Qualcomm MSM platforms.

 */



#ifndef _MACH_MSM_I2C_MSM_H

#define _MACH_MSM_I2C_MSM_H



/**

 * i2c_msm_v2_platform_data: i2c-msm-v2 driver configuration data

 *

 * @clk_freq_in core clock frequency in Hz

 * @clk_freq_out bus clock frequency in Hz

 * @bam_pipe_idx_cons index of BAM's consumer pipe

 * @bam_pipe_idx_prod index of BAM's producer pipe

 * @bam_disable disables DMA transfers.

 * @noise_rjct_scl number of low samples on clock line to consider it low.

 * @noise_rjct_sda number of low samples on data  line to consider it low.

 * @active_only when set, votes when system active and removes the vote when

 *       system goes idle (optimises for performance). When unset, voting using

 *       runtime pm (optimizes for power).

 * @master_id master id number of the i2c core or its wrapper (BLSP/GSBI).

 *       When zero, clock path voting is disabled.

 */

struct i2c_msm_v2_platform_data {

	int  clk_freq_in;

	int  clk_freq_out;

	u32  bam_pipe_idx_cons;

	u32  bam_pipe_idx_prod;

	bool bam_disable;

	int  noise_rjct_scl;

	int  noise_rjct_sda;

	bool active_only;

	u32  master_id;

};



#endif

drivers/i2c/busses/i2c-msm-v2.c

+138 −165
Original line number Diff line number Diff line
@@ -34,10 +34,9 @@ 
#include <linux/of.h>

#include <linux/of_i2c.h>

#include <linux/debugfs.h>

#include <mach/i2c-msm.h>

#include <mach/sps.h>

#include <mach/msm_bus.h>

#include <mach/msm_bus_board.h>

#include <linux/msm-sps.h>

#include <linux/msm-bus.h>

#include <linux/msm-bus-board.h>

#include "i2c-msm-v2.h"



#ifdef DEBUG
@@ -139,7 +138,7 @@ static void i2c_msm_qup_fifo_calc_size(struct i2c_msm_ctrl *ctrl) 
	fifo->output_fifo_sz = i2c_msm_reg_io_modes_out_blk_sz(reg_data) *

					i2c_msm_fifo_sz_table[output_fifo_size];



	i2c_msm_dbg(ctrl, MSM_PROF, "QUP input-sz:%d, input-sz:%d",

	i2c_msm_dbg(ctrl, MSM_PROF, "QUP input-sz:%zu, input-sz:%zu",

			fifo->input_fifo_sz, fifo->output_fifo_sz);



}
@@ -389,9 +388,10 @@ static void i2c_msm_dbg_xfer_dump(struct i2c_msm_ctrl *ctrl) 
	}



	dev_info(ctrl->dev,

		"n-msgs:%d mode:%s in-bc:%d out-bc:%d in-ovrhd:%d out-ovrhd:%d "

		"timeout:%dmsec msg-idx:%d is_rx:%d ff-sent-bc:%d ff-recv-bc:%d\n"

		, xfer->msg_cnt, i2c_msm_mode_str_tbl[xfer->mode_id],

		"n-msgs:%d mode:%s in-bc:%zu out-bc:%zu in-ovrhd:%zu "

		"out-ovrhd:%zu timeout:%dmsec msg-idx:%d is_rx:%d "

		"ff-tx-bc:%zu ff-rx-bc:%zu\n",

		xfer->msg_cnt, i2c_msm_mode_str_tbl[xfer->mode_id],

		xfer->rx_cnt, xfer->tx_cnt, xfer->rx_ovrhd_cnt,

		xfer->tx_ovrhd_cnt, jiffies_to_msecs(xfer->timeout),

		xfer->cur_buf.msg_idx, xfer->cur_buf.is_rx, fifo->tx_bc,
@@ -520,7 +520,7 @@ static u8 *i2c_msm_buf_to_ptr(struct i2c_msm_xfer_buf *buf) 
static void i2c_msm_prof_evnt_add(struct i2c_msm_ctrl *ctrl,

				enum msm_i2_debug_level dbg_level,

				i2c_msm_prof_dump_func_func_t dump_func,

				u32 data0, u32 data1, u32 data2)

				u64 data0, u32 data1, u32 data2)

{

	struct i2c_msm_xfer       *xfer  = &ctrl->xfer;

	struct i2c_msm_prof_event *event;
@@ -538,17 +538,17 @@ static void i2c_msm_prof_evnt_add(struct i2c_msm_ctrl *ctrl, 


	getnstimeofday(&event->time);

	event->dump_func = dump_func;

	event->data[0] = data0;

	event->data[1] = data1;

	event->data[2] = data2;

	event->data0 = data0;

	event->data1 = data1;

	event->data2 = data2;

}



void i2c_msm_prof_dump_xfer_beg(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	dev_info(ctrl->dev,

		"-->.%03zums XFER_BEG msg_cnt:%x addr:0x%x\n",

		usec, event->data[0], event->data[1]);

		"-->.%03zums XFER_BEG msg_cnt:%llx addr:0x%x\n",

		usec, event->data0, event->data1);

}



/* string table for enum i2c_msm_err_bit_field */
@@ -564,8 +564,8 @@ static const char * const i2c_msm_err_str_tbl[] = { 
void i2c_msm_prof_dump_xfer_end(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	int ret = event->data[0];

	int err = event->data[1];

	int ret = event->data0;

	int err = event->data1;

	int bc  = ctrl->xfer.rx_cnt + ctrl->xfer.rx_ovrhd_cnt +

		  ctrl->xfer.tx_cnt + ctrl->xfer.tx_ovrhd_cnt;

	int bc_sec = (bc * 1000000) / (msec * 1000 + usec);
@@ -575,24 +575,24 @@ void i2c_msm_prof_dump_xfer_end(struct i2c_msm_ctrl *ctrl, 
	dev_info(ctrl->dev,

		"%3zu.%03zums XFER_END "

		"ret:%d err:[%s] msgs_sent:%d BC:%d B/sec:%d i2c-stts:%s\n" ,

		msec, usec, ret, i2c_msm_err_str_tbl[err], event->data[2],

		msec, usec, ret, i2c_msm_err_str_tbl[err], event->data2,

		bc, bc_sec, status);

}



void i2c_msm_prof_dump_irq_begn(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	dev_info(ctrl->dev, "%3zu.%03zums  IRQ_BEG irq:%d\n",

						msec, usec, event->data[0]);

	dev_info(ctrl->dev, "%3zu.%03zums  IRQ_BEG irq:%lld\n",

						msec, usec, event->data0);

}



void i2c_msm_prof_dump_irq_end(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	char str[I2C_MSM_REG_2_STR_BUF_SZ];

	u32 mstr_stts = event->data[0];

	u32 qup_oper  = event->data[1];

	u32 err_flgs  = event->data[2];

	u32 mstr_stts = event->data0;

	u32 qup_oper  = event->data1;

	u32 err_flgs  = event->data2;

	dev_info(ctrl->dev,

		"%3zu.%03zums  IRQ_END "

		"MSTR_STTS:0x%x QUP_OPER:0x%x ERR_FLGS:0x%x\n",
@@ -608,8 +608,8 @@ void i2c_msm_prof_dump_irq_end(struct i2c_msm_ctrl *ctrl, 
				mstr_stts, str, sizeof(str),

				i2c_msm_qup_i2c_stat_fields_map);



		dev_info(ctrl->dev, "            |->MSTR_STTS:0x%x %s\n",

						event->data[0], str);

		dev_info(ctrl->dev, "            |->MSTR_STTS:0x%llx %s\n",

						event->data0, str);

	}

	/* register QUP_OPERATIONAL */

	if (qup_oper &
@@ -620,7 +620,7 @@ void i2c_msm_prof_dump_irq_end(struct i2c_msm_ctrl *ctrl, 
				i2c_msm_qup_op_fields_map);



		dev_info(ctrl->dev, "            |-> QUP_OPER:0x%x %s\n",

						event->data[1], str);

						event->data1, str);

	}

	/* register ERR_FLAGS */

	if (err_flgs) {
@@ -629,32 +629,32 @@ void i2c_msm_prof_dump_irq_end(struct i2c_msm_ctrl *ctrl, 
				i2c_msm_qup_err_flags_fields_map);



		dev_info(ctrl->dev, "            |-> ERR_FLGS:0x%x %s\n",

						event->data[2], str);

						event->data2, str);

	}

}



void i2c_msm_prof_dump_next_buf(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	struct i2c_msg *msg = ctrl->xfer.msgs + event->data[0];

	struct i2c_msg *msg = ctrl->xfer.msgs + event->data0;

	dev_info(ctrl->dev,

		"%3zu.%03zums XFER_BUF msg[%d] pos:%d adr:0x%x "

		"%3zu.%03zums XFER_BUF msg[%lld] pos:%d adr:0x%x "

		"len:%d is_rx:0x%x last:0x%x\n",

		msec, usec, event->data[0], event->data[1], msg->addr, msg->len,

		msec, usec, event->data0, event->data1, msg->addr, msg->len,

		(msg->flags & I2C_M_RD),

		event->data[0] == (ctrl->xfer.msg_cnt - 1));

		event->data0 == (ctrl->xfer.msg_cnt - 1));



}



void i2c_msm_prof_dump_scan_sum(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	u32 bc_rx       = (event->data[0] & 0xff);

	u32 bc_rx_ovrhd = (event->data[0] >> 16);

	u32 bc_tx       = (event->data[1] & 0xff);

	u32 bc_tx_ovrhd = (event->data[1] >> 16);

	u32 timeout     = (event->data[2] & 0xfff);

	u32 mode        = (event->data[2] >> 24);

	u32 bc_rx       = (event->data0 & 0xff);

	u32 bc_rx_ovrhd = (event->data0 >> 16);

	u32 bc_tx       = (event->data1 & 0xff);

	u32 bc_tx_ovrhd = (event->data1 >> 16);

	u32 timeout     = (event->data2 & 0xfff);

	u32 mode        = (event->data2 >> 24);

	u32 bc      = bc_rx + bc_rx_ovrhd + bc_tx + bc_tx_ovrhd;

	dev_info(ctrl->dev,

		"%3zu.%03zums SCN_SMRY BC:%u rx:%u+ovrhd:%u tx:%u+ovrhd:%u "
@@ -668,8 +668,8 @@ void i2c_msm_prof_dump_cmplt_ok(struct i2c_msm_ctrl *ctrl, 
{

	dev_info(ctrl->dev,

		"%3zu.%03zums  DONE_OK timeout-used:%umsec time_left:%umsec\n",

		msec, usec, jiffies_to_msecs(event->data[0]),

		jiffies_to_msecs(event->data[1]));

		msec, usec, jiffies_to_msecs(event->data0),

		jiffies_to_msecs(event->data1));

}



void i2c_msm_prof_dump_cmplt_fl(struct i2c_msm_ctrl *ctrl,
@@ -678,29 +678,29 @@ void i2c_msm_prof_dump_cmplt_fl(struct i2c_msm_ctrl *ctrl, 
	dev_info(ctrl->dev,

		"%3zu.%03zums  TIMEOUT-error timeout-used:%umsec. "

		"Check GPIOs configuration\n",

		msec, usec, jiffies_to_msecs(event->data[0]));

		msec, usec, jiffies_to_msecs(event->data0));

}



void i2c_msm_prof_dump_vlid_end(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	int  ret        = (int)(event->data[0] & 0xff);

	enum i2c_msm_qup_state state = ((event->data[0] << 16) & 0xf);

	u32  status     = event->data[2];

	int  ret        = (int)(event->data0 & 0xff);

	enum i2c_msm_qup_state state = ((event->data0 << 16) & 0xf);

	u32  status     = event->data2;



	dev_info(ctrl->dev,

	"%3zu.%03zums SET_STTE set:%s ret:%d rd_cnt:%u reg_val:0x%x vld:%d\n",

	msec, usec, i2c_msm_reg_qup_state_to_str[state], ret,

	event->data[1], status, BIT_IS_SET(status, 2));

	event->data1, status, BIT_IS_SET(status, 2));

}



void i2c_msm_prof_dump_actv_end(struct i2c_msm_ctrl *ctrl,

		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	dev_info(ctrl->dev,

	    "%3zu.%03zums ACTV_END ret:%d jiffies_left:%u/%u read_cnt:%u\n",

	    msec, usec, event->data[0], event->data[1],

	    I2C_MSM_MAX_POLL_MSEC, event->data[2]);

	    "%3zu.%03zums ACTV_END ret:%lld jiffies_left:%u/%u read_cnt:%u\n",

	    msec, usec, event->data0, event->data1,

	    I2C_MSM_MAX_POLL_MSEC, event->data2);

}



void i2c_msm_prof_dump_bam_flsh(struct i2c_msm_ctrl *ctrl,
@@ -713,8 +713,8 @@ void i2c_msm_prof_dump_pip_dscn(struct i2c_msm_ctrl *ctrl, 
		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	struct i2c_msm_bam_pipe *pipe =

			(struct i2c_msm_bam_pipe *) event->data[0];

	int ret = event->data[1];

			(struct i2c_msm_bam_pipe *) ((ulong) event->data0);

	int ret = event->data1;

	dev_info(ctrl->dev,

		"%3zu.%03zums PIP_DCNCT sps_disconnect(hndl:0x%p %s):%d\n",

		msec, usec, pipe->handle, pipe->name, ret);
@@ -724,8 +724,8 @@ void i2c_msm_prof_dump_pip_cnct(struct i2c_msm_ctrl *ctrl, 
		struct i2c_msm_prof_event *event, size_t msec, size_t usec)

{

	struct i2c_msm_bam_pipe *pipe =

				(struct i2c_msm_bam_pipe *) event->data[0];

	int ret = event->data[1];

			(struct i2c_msm_bam_pipe *) ((ulong) event->data0);

	int ret = event->data1;

	dev_info(ctrl->dev,

		"%3zu.%03zums PIP_CNCT sps_connect(hndl:0x%p %s):%d\n",

		msec, usec, pipe->handle, pipe->name, ret);
@@ -1016,7 +1016,7 @@ i2c_msm_qup_xfer_init_reset_state(struct i2c_msm_ctrl *ctrl) 


bool i2c_msm_xfer_is_high_speed(struct i2c_msm_ctrl *ctrl)

{

	return ctrl->pdata->clk_freq_out > I2C_MSM_CLK_FAST_MAX_FREQ;

	return ctrl->rsrcs.clk_freq_out > I2C_MSM_CLK_FAST_MAX_FREQ;

}



/*
@@ -1028,17 +1028,15 @@ static void i2c_msm_qup_xfer_init_run_state(struct i2c_msm_ctrl *ctrl) 
	u32 val = 0;



	if (i2c_msm_xfer_is_high_speed(ctrl)) {

		val = I2C_MSM_SCL_NOISE_REJECTION(val,

						ctrl->noise_rjct_scl);

		val = I2C_MSM_SDA_NOISE_REJECTION(val,

						ctrl->noise_rjct_sda);

		val = I2C_MSM_CLK_DIV(val, ctrl->pdata->clk_freq_in,

					ctrl->pdata->clk_freq_out, true);

		val = I2C_MSM_SCL_NOISE_REJECTION(val, ctrl->noise_rjct_scl);

		val = I2C_MSM_SDA_NOISE_REJECTION(val, ctrl->noise_rjct_sda);

		val = I2C_MSM_CLK_DIV(val, ctrl->rsrcs.clk_freq_in,

					ctrl->rsrcs.clk_freq_out, true);

	} else {

		val = I2C_MSM_SCL_NOISE_REJECTION(val, ctrl->noise_rjct_scl);

		val = I2C_MSM_SDA_NOISE_REJECTION(val, ctrl->noise_rjct_sda);

		val = I2C_MSM_CLK_DIV(val, ctrl->pdata->clk_freq_in,

					ctrl->pdata->clk_freq_out, false);

		val = I2C_MSM_CLK_DIV(val, ctrl->rsrcs.clk_freq_in,

					ctrl->rsrcs.clk_freq_out, false);

	}



	writel_relaxed(val, base + QUP_I2C_MASTER_CLK_CTL);
@@ -1325,7 +1323,7 @@ static int i2c_msm_fifo_create_struct(struct i2c_msm_ctrl *ctrl) 
					kmalloc(sizeof(*fifo), GFP_KERNEL);

	if (!fifo) {

		dev_err(ctrl->dev,

		  "error on allocating memory for fifo mode. malloc(size:%d\n)",

		  "error on allocating memory for fifo mode. malloc(size:%zu\n)",

		  sizeof(*fifo));

		return -ENOMEM;

	}
@@ -1393,18 +1391,18 @@ static int i2c_msm_bam_xfer_prepare(struct i2c_msm_ctrl *ctrl) 
		if (dma_mapping_error(ctrl->dev, data.phy_addr)) {

			dev_err(ctrl->dev,

			  "error DMA mapping BAM buffers. err:%lld "

			  "buf_vrtl:0x%p data_len:%d dma_dir:%s\n",

			  "buf_vrtl:0x%p data_len:%zu dma_dir:%s\n",

			  (u64) data.phy_addr, data.vrtl_addr, buf->len,

			  ((buf_dma_dirctn == DMA_FROM_DEVICE)

				? "DMA_FROM_DEVICE" : "DMA_TO_DEVICE"));

			return DMA_ERROR_CODE;

			return -EFAULT;

		}



		/* copy 8 bytes. Only tag.len bytes will be used */

		*((u64 *)tag_arr_itr_vrtl_addr) =  buf->out_tag.val;



		i2c_msm_dbg(ctrl, MSM_DBG,

			"vrtl:0x%p phy:0x%llx val:0x%llx sizeof(dma_addr_t):%d",

			"vrtl:0x%p phy:0x%llx val:0x%llx sizeof(dma_addr_t):%zu",

			tag_arr_itr_vrtl_addr, (u64) tag_arr_itr_phy_addr,

			*((u64 *)tag_arr_itr_vrtl_addr), sizeof(dma_addr_t));
@@ -1494,7 +1492,7 @@ static int i2c_msm_bam_xfer_process(struct i2c_msm_ctrl *ctrl) 
	int  ret           = 0;

	u32  bam_flags     = 0; /* bam_flags!=0 only on last xfer */

	char str[64];

	i2c_msm_dbg(ctrl, MSM_DBG, "Going to enqueue %d buffers in BAM",

	i2c_msm_dbg(ctrl, MSM_DBG, "Going to enqueue %zu buffers in BAM",

							bam->buf_arr_cnt);



	cons = &bam->pipe[I2C_MSM_BAM_CONS];
@@ -1530,7 +1528,7 @@ static int i2c_msm_bam_xfer_process(struct i2c_msm_ctrl *ctrl) 
		pipe = buf_itr->is_rx ? prod : cons;



		i2c_msm_dbg(ctrl, MSM_DBG,

			"Queue data buf to %s pipe desc(phy:0x%llx len:%d) "

			"Queue data buf to %s pipe desc(phy:0x%llx len:%zu) "

			"EOT:%d NWD:%d",

			pipe->name, (u64) buf_itr->ptr.phy_addr, buf_itr->len,

			!!(bam_flags & SPS_IOVEC_FLAG_EOT),
@@ -1585,7 +1583,7 @@ static int i2c_msm_bam_pipe_diconnect(struct i2c_msm_ctrl *ctrl, 
	int ret = sps_disconnect(pipe->handle);

	if (ret) {

		i2c_msm_prof_evnt_add(ctrl, MSM_ERR, i2c_msm_prof_dump_pip_dscn,

					(u32) pipe, (u32)ret, 0);

						(ulong) pipe, (u32)ret, 0);

		return ret;

	}

	pipe->is_init = false;
@@ -1606,7 +1604,7 @@ static int i2c_msm_bam_pipe_connect(struct i2c_msm_ctrl *ctrl, 
	ret = sps_connect(pipe->handle, config);

	if (ret) {

		i2c_msm_prof_evnt_add(ctrl, MSM_ERR, i2c_msm_prof_dump_pip_cnct,

						(u32) pipe, (u32)ret, 0);

						(ulong) pipe, (u32)ret, 0);

		return ret;

	}
@@ -1682,15 +1680,13 @@ static int i2c_msm_bam_pipe_init(struct i2c_msm_ctrl *ctrl, 
		config->destination     = bam->handle;

		config->mode            = SPS_MODE_DEST;

		config->src_pipe_index  = 0;

		config->dest_pipe_index =

					ctrl->pdata->bam_pipe_idx_cons;

		config->dest_pipe_index = ctrl->rsrcs.bam_pipe_idx_cons;

		pipe->desc_cnt_max      = I2C_MSM_BAM_CONS_SZ;

	} else {

		config->source          = bam->handle;

		config->destination     = SPS_DEV_HANDLE_MEM;

		config->mode            = SPS_MODE_SRC;

		config->src_pipe_index  =

					ctrl->pdata->bam_pipe_idx_prod;

		config->src_pipe_index  = ctrl->rsrcs.bam_pipe_idx_prod;

		config->dest_pipe_index = 0;

		pipe->desc_cnt_max      = I2C_MSM_BAM_PROD_SZ;

	}
@@ -1804,7 +1800,7 @@ pipe_error: 
	return ret;

}



static int i2c_msm_bam_reg_dev(struct i2c_msm_ctrl *ctrl, u32 *bam_handle)

static int i2c_msm_bam_reg_dev(struct i2c_msm_ctrl *ctrl, ulong *bam_handle)

{

	int                  ret;

	struct i2c_msm_xfer_mode_bam *bam = i2c_msm_bam_get_struct(ctrl);
@@ -1846,7 +1842,7 @@ static int i2c_msm_bam_reg_dev(struct i2c_msm_ctrl *ctrl, u32 *bam_handle) 
static int i2c_msm_bam_init(struct i2c_msm_ctrl *ctrl)

{

	struct i2c_msm_xfer_mode_bam *bam = i2c_msm_bam_get_struct(ctrl);

	u32             bam_handle;

	ulong           bam_handle;

	int             ret;

	u8             *tags_space_virt_addr;

	dma_addr_t      tags_space_phy_addr;
@@ -1976,7 +1972,7 @@ static int i2c_msm_bam_xfer(struct i2c_msm_ctrl *ctrl) 
	ret = i2c_msm_bam_xfer_process(ctrl);

	if (ret)

		dev_err(ctrl->dev,

			"error i2c_msm_bam_xfer_process(n_bufs:%d):%d\n",

			"error i2c_msm_bam_xfer_process(n_bufs:%zu):%d\n",

			bam->buf_arr_cnt, ret);



err_bam_xfer:
@@ -1998,7 +1994,7 @@ static int i2c_msm_bam_create_struct(struct i2c_msm_ctrl *ctrl) 


	if (!bam) {

		dev_err(ctrl->dev,

		   "error on allocating memory for bam mode. malloc(size:%d)\n",

		   "error on allocating memory for bam mode. malloc(size:%zu)\n",

		   sizeof(*bam));

		return -ENOMEM;

	}
@@ -2104,7 +2100,7 @@ static void i2c_msm_clk_path_unvote(struct i2c_msm_ctrl *ctrl) 


static void i2c_msm_clk_path_teardown(struct i2c_msm_ctrl *ctrl)

{

	if (ctrl->pdata->active_only)

	if (ctrl->rsrcs.clk_path_vote.actv_only)

		i2c_msm_clk_path_unvote(ctrl);



	if (ctrl->rsrcs.clk_path_vote.client_hdl) {
@@ -2150,14 +2146,14 @@ static int i2c_msm_clk_path_init_structs(struct i2c_msm_ctrl *ctrl) 
	}



	paths[I2C_MSM_CLK_PATH_SUSPEND_VEC] = (struct msm_bus_vectors) {

		.src = ctrl->pdata->master_id,

		.src = ctrl->rsrcs.clk_path_vote.mstr_id,

		.dst = MSM_BUS_SLAVE_EBI_CH0,

		.ab  = 0,

		.ib  = 0,

	};



	paths[I2C_MSM_CLK_PATH_RESUME_VEC]  = (struct msm_bus_vectors) {

		.src = ctrl->pdata->master_id,

		.src = ctrl->rsrcs.clk_path_vote.mstr_id,

		.dst = MSM_BUS_SLAVE_EBI_CH0,

		.ab  = I2C_MSM_CLK_PATH_AVRG_BW(ctrl),

		.ib  = I2C_MSM_CLK_PATH_BRST_BW(ctrl),
@@ -2174,10 +2170,10 @@ static int i2c_msm_clk_path_init_structs(struct i2c_msm_ctrl *ctrl) 
	};



	*ctrl->rsrcs.clk_path_vote.pdata = (struct msm_bus_scale_pdata) {

		.active_only  = ctrl->pdata->active_only,

		.name         = dev_name(ctrl->dev),

		.num_usecases = 2,

		.usecase      = usecases,

		.num_usecases = 2,

		.name         = dev_name(ctrl->dev),

		.active_only  = ctrl->rsrcs.clk_path_vote.actv_only,

	};



	return 0;
@@ -2211,25 +2207,26 @@ static int i2c_msm_clk_path_postponed_register(struct i2c_msm_ctrl *ctrl) 
		if (ctrl->rsrcs.clk_path_vote.reg_err) {

			/* log a success message if an error msg was logged */

			ctrl->rsrcs.clk_path_vote.reg_err = false;

			i2c_msm_dbg(ctrl, MSM_DBG,

			  "success on late msm_bus_scale_register_client"

			  "(mstr-id:%d actv-only:%d):0x%x",

			  ctrl->pdata->master_id, ctrl->pdata->active_only,

			dev_err(ctrl->dev,

				"msm_bus_scale_register_client(mstr-id:%d "

				"actv-only:%d):0x%x (ok)",

				ctrl->rsrcs.clk_path_vote.mstr_id,

				ctrl->rsrcs.clk_path_vote.actv_only,

				ctrl->rsrcs.clk_path_vote.client_hdl);

		}



		if (ctrl->pdata->active_only)

		if (ctrl->rsrcs.clk_path_vote.actv_only)

			i2c_msm_clk_path_vote(ctrl);

	} else {

		/* guard to log only one error on multiple failure */

		if (!ctrl->rsrcs.clk_path_vote.reg_err) {

			ctrl->rsrcs.clk_path_vote.reg_err = true;



			i2c_msm_dbg(ctrl, MSM_DBG,

			  "msm_bus_scale_register_client(mstr-id:%d actv-only:"

			  "%d):0 (fail) prob i2c probed before bus_scale."

			  " not a problem",

			  ctrl->pdata->master_id, ctrl->pdata->active_only);

			dev_info(ctrl->dev,

				"msm_bus_scale_register_client(mstr-id:%d "

				"actv-only:%d):0 (not a problem)",

				ctrl->rsrcs.clk_path_vote.mstr_id,

				ctrl->rsrcs.clk_path_vote.actv_only);

		}

	}
@@ -2242,13 +2239,14 @@ static void i2c_msm_clk_path_init(struct i2c_msm_ctrl *ctrl) 
	 * bail out if path voting is diabled (master_id == 0) or if it is

	 * already registered (client_hdl != 0)

	 */

	if (!ctrl->pdata->master_id || ctrl->rsrcs.clk_path_vote.client_hdl)

	if (!ctrl->rsrcs.clk_path_vote.mstr_id ||

		ctrl->rsrcs.clk_path_vote.client_hdl)

		return;



	/* if fail once then try no more */

	if (!ctrl->rsrcs.clk_path_vote.pdata &&

					i2c_msm_clk_path_init_structs(ctrl)) {

		ctrl->pdata->master_id = 0;

		ctrl->rsrcs.clk_path_vote.mstr_id = 0;

		return;

	};
@@ -2256,7 +2254,7 @@ static void i2c_msm_clk_path_init(struct i2c_msm_ctrl *ctrl) 
	if (i2c_msm_clk_path_postponed_register(ctrl))

		return;



	if (ctrl->pdata->active_only)

	if (ctrl->rsrcs.clk_path_vote.actv_only)

		i2c_msm_clk_path_vote(ctrl);

}
@@ -2551,7 +2549,7 @@ static void i2c_msm_qup_choose_mode(struct i2c_msm_ctrl *ctrl) 
		xfer->mode_id = ctrl->dbgfs.force_xfer_mode;

	else if (((rx_cnt_sum < fifo->input_fifo_sz) &&

		  (tx_cnt_sum < fifo->output_fifo_sz)) ||

						ctrl->pdata->bam_disable)

						ctrl->rsrcs.disable_dma)

		xfer->mode_id = I2C_MSM_XFER_MODE_FIFO;

	else

		xfer->mode_id = I2C_MSM_XFER_MODE_BAM;
@@ -2617,7 +2615,7 @@ static void i2c_msm_xfer_calc_timeout(struct i2c_msm_ctrl *ctrl) 
{

	size_t byte_cnt = ctrl->xfer.rx_cnt + ctrl->xfer.tx_cnt;

	size_t bit_cnt  = byte_cnt * 9;

	size_t bit_usec = (bit_cnt * USEC_PER_SEC) / ctrl->pdata->clk_freq_out;

	size_t bit_usec = (bit_cnt * USEC_PER_SEC) / ctrl->rsrcs.clk_freq_out;

	size_t loging_ovrhd_coef = ctrl->dbgfs.dbg_lvl + 1;

	size_t safety_coef   = I2C_MSM_TIMEOUT_SAFTY_COEF * loging_ovrhd_coef;

	size_t xfer_max_usec = (bit_usec * safety_coef) +
@@ -2724,7 +2722,7 @@ static bool i2c_msm_xfer_next_msg(struct i2c_msm_ctrl *ctrl) 
		i2c_msm_dbg_tag_to_str(&cur_buf->out_tag, str, sizeof(str));

		dev_info(ctrl->dev,

			"msg[%d] first:0x%x last:0x%x new_adr:0x%x inp:0x%x "

			"len:%d adr:0x%x tag:%s\n",

			"len:%zu adr:0x%x tag:%s\n",

			cur_buf->msg_idx, is_first_msg, is_last_msg,

			start_req, cur_buf->is_rx, cur_buf->len, slv_addr,

			str);
@@ -2881,7 +2879,6 @@ struct i2c_msm_dt_to_pdata_map { 


static int i2c_msm_dt_to_pdata_populate(struct i2c_msm_ctrl *ctrl,

					struct platform_device *pdev,

					struct i2c_msm_v2_platform_data *pdata,

					struct i2c_msm_dt_to_pdata_map *itr)

{

	int  ret, err = 0;
@@ -2941,48 +2938,32 @@ static int i2c_msm_dt_to_pdata_populate(struct i2c_msm_ctrl *ctrl, 
 * @return zero on success or negative error code

 */

static int i2c_msm_rsrcs_dt_to_pdata(struct i2c_msm_ctrl *ctrl,

					struct platform_device *pdev,

					struct i2c_msm_v2_platform_data **pdata)

					struct platform_device *pdev)

{

	int ret = 0;

	*pdata = devm_kzalloc(&pdev->dev, sizeof(**pdata), GFP_KERNEL);

	if (!*pdata) {

		dev_err(ctrl->dev,

			"error Unable to allocate mem for platform data\n");

		ret = -ENOMEM;

	} else {

	struct i2c_msm_dt_to_pdata_map map[] = {

		{"i2c",

			&pdev->id,                       DT_REQ,  DT_ID,  -1},

		{"qcom,clk-freq-out",

			&(*pdata)->clk_freq_out,         DT_REQ,  DT_U32,  0},

		{"qcom,clk-freq-in",

			&(*pdata)->clk_freq_in,          DT_REQ,  DT_U32,  0},

		{"qcom,bam-pipe-idx-cons",

			&(*pdata)->bam_pipe_idx_cons,    DT_OPT,  DT_U32,  0},

		{"qcom,bam-pipe-idx-prod",

			&(*pdata)->bam_pipe_idx_prod,    DT_OPT,  DT_U32,  0},

		{"qcom,bam-disable",

			&(*pdata)->bam_disable,          DT_OPT,  DT_BOOL, 0},

		{"qcom,master-id",

			&(*pdata)->master_id,            DT_SGST, DT_U32,  0},

		{"qcom,active-only",

			&(*pdata)->active_only,          DT_OPT,  DT_BOOL, 0},

		{"qcom,noise-rjct-scl",

			&(*pdata)->noise_rjct_scl,       DT_OPT,  DT_U32,  0},

		{"qcom,noise-rjct-sda",

			&(*pdata)->noise_rjct_sda,       DT_OPT,  DT_U32,  0},

	{"i2c",				&pdev->id,	DT_REQ,  DT_ID,  -1},

	{"qcom,clk-freq-out",		&ctrl->rsrcs.clk_freq_out,

							DT_REQ,  DT_U32,  0},

	{"qcom,clk-freq-in",		&ctrl->rsrcs.clk_freq_in,

							DT_REQ,  DT_U32,  0},

	{"qcom,bam-pipe-idx-cons",	&(ctrl->rsrcs.bam_pipe_idx_cons),

							DT_OPT,  DT_U32,  0},

	{"qcom,bam-pipe-idx-prod",	&(ctrl->rsrcs.bam_pipe_idx_prod),

							DT_OPT,  DT_U32,  0},

	{"qcom,bam-disable",		&(ctrl->rsrcs.disable_dma),

							DT_OPT,  DT_BOOL, 0},

	{"qcom,master-id",		&(ctrl->rsrcs.clk_path_vote.mstr_id),

							DT_SGST, DT_U32,  0},

	{"qcom,active-only",		&(ctrl->rsrcs.clk_path_vote.actv_only),

							DT_OPT,  DT_BOOL, 0},

	{"qcom,noise-rjct-scl",		&(ctrl->noise_rjct_scl),

							DT_OPT,  DT_U32,  0},

	{"qcom,noise-rjct-sda",		&(ctrl->noise_rjct_sda),

							DT_OPT,  DT_U32,  0},

	{NULL,  NULL,					0,       0,       0},

	};



		ret = i2c_msm_dt_to_pdata_populate(ctrl, pdev, *pdata, map);

		if (ret) {

			devm_kfree(&pdev->dev, *pdata);

			*pdata = NULL;

		};

	}



	return ret;

	return i2c_msm_dt_to_pdata_populate(ctrl, pdev, map);

}



/*
@@ -3120,11 +3101,11 @@ static int i2c_msm_rsrcs_clk_init(struct i2c_msm_ctrl *ctrl) 
{

	int ret = 0;



	if ((ctrl->pdata->clk_freq_out <= 0) ||

	    (ctrl->pdata->clk_freq_out > I2C_MSM_CLK_HIGH_MAX_FREQ)) {

	if ((ctrl->rsrcs.clk_freq_out <= 0) ||

	    (ctrl->rsrcs.clk_freq_out > I2C_MSM_CLK_HIGH_MAX_FREQ)) {

		dev_err(ctrl->dev,

			"error clock frequency %dHZ is not supported\n",

			ctrl->pdata->clk_freq_out);

			"error clock frequency %dKHZ is not supported\n",

			(ctrl->rsrcs.clk_freq_out / 1000));

		return -EIO;

	}
@@ -3135,10 +3116,10 @@ static int i2c_msm_rsrcs_clk_init(struct i2c_msm_ctrl *ctrl) 
		return ret;

	}



	ret = clk_set_rate(ctrl->rsrcs.core_clk, ctrl->pdata->clk_freq_in);

	ret = clk_set_rate(ctrl->rsrcs.core_clk, ctrl->rsrcs.clk_freq_in);

	if (ret) {

		dev_err(ctrl->dev, "error on clk_set_rate(core_clk, %dHz):%d\n",

						ctrl->pdata->clk_freq_in, ret);

		dev_err(ctrl->dev, "error on clk_set_rate(core_clk, %dKHz):%d\n",

					(ctrl->rsrcs.clk_freq_in / 1000), ret);

		goto err_set_rate;

	}
@@ -3339,7 +3320,7 @@ static void i2c_msm_dbgfs_init(struct i2c_msm_ctrl *ctrl) 
		{"bus-clear",       I2C_MSM_DFS_MD_W, I2C_MSM_DFS_FILE,

				&i2c_msm_dbgfs_do_bus_clear_fops,  NULL},

		{"freq-out-hz",     I2C_MSM_DFS_MD_RW, I2C_MSM_DFS_U32,

				NULL, &ctrl->pdata->clk_freq_out},

				NULL, &ctrl->rsrcs.clk_freq_out},

		{NULL, 0, 0, NULL , NULL}, /* null terminator */

	};

	return i2c_msm_dbgfs_create(ctrl, i2c_msm_dbgfs_map);
@@ -3359,7 +3340,7 @@ static void i2c_msm_pm_clk_unvote(struct i2c_msm_ctrl *ctrl) 
{

	clk_disable_unprepare(ctrl->rsrcs.core_clk);

	clk_disable_unprepare(ctrl->rsrcs.iface_clk);

	if (!ctrl->pdata->active_only)

	if (!ctrl->rsrcs.clk_path_vote.actv_only)

		i2c_msm_clk_path_unvote(ctrl);

}
@@ -3368,7 +3349,7 @@ static void i2c_msm_pm_clk_vote(struct i2c_msm_ctrl *ctrl) 
	int ret;



	i2c_msm_clk_path_init(ctrl);

	if (!ctrl->pdata->active_only)

	if (!ctrl->rsrcs.clk_path_vote.actv_only)

		i2c_msm_clk_path_vote(ctrl);



	ret = clk_prepare_enable(ctrl->rsrcs.iface_clk);
@@ -3564,7 +3545,6 @@ static void i2c_msm_frmwrk_unreg(struct i2c_msm_ctrl *ctrl) 
static int i2c_msm_probe(struct platform_device *pdev)

{

	struct i2c_msm_ctrl             *ctrl;

	struct i2c_msm_v2_platform_data *pdata;

	int ret = 0;



	dev_info(&pdev->dev, "probing driver i2c-msm-v2\n");
@@ -3577,21 +3557,14 @@ static int i2c_msm_probe(struct platform_device *pdev) 
	ctrl->dbgfs.dbg_lvl         = DEFAULT_DBG_LVL;

	ctrl->dbgfs.force_xfer_mode = I2C_MSM_XFER_MODE_NONE;



	if (pdev->dev.of_node) {

		ret = i2c_msm_rsrcs_dt_to_pdata(ctrl, pdev, &pdata);

		if (ret)

			return ret;

	} else {

		pdata = pdev->dev.platform_data;

	if (!pdev->dev.of_node) {

		dev_err(&pdev->dev, "error: null device-tree node");

		return -EBADE;

	}



	if (!pdata) {

		dev_err(&pdev->dev,

			"error platform data is not initialised (is NULL)\n");

		devm_kfree(&pdev->dev, ctrl);

		return -ENOSYS;

	}

	ctrl->pdata    = pdata;

	ret = i2c_msm_rsrcs_dt_to_pdata(ctrl, pdev);

	if (ret)

		return ret;



	ret = i2c_msm_rsrcs_mem_init(pdev, ctrl);

	if (ret)