Patchwork [v3,1/2] i2c: add DMA support for freescale i2c driver

login
register
mail settings
Submitter Yao Yuan
Date March 13, 2014, 1:47 a.m.
Message ID <1394675277-24913-2-git-send-email-yao.yuan@freescale.com>
Download mbox | patch
Permalink /patch/329762/
State Superseded
Headers show

Comments

Yao Yuan - March 13, 2014, 1:47 a.m.
Add dma support for i2c. This function depend on DMA driver.
You can turn on it by write both the dmas and dma-name properties in dts node.

Signed-off-by: Yuan Yao <yao.yuan@freescale.com>
---
 drivers/i2c/busses/i2c-imx.c | 354 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 306 insertions(+), 48 deletions(-)
Marek Vasut - March 23, 2014, 3:49 a.m.
On Thursday, March 13, 2014 at 02:47:56 AM, Yuan Yao wrote:
> Add dma support for i2c. This function depend on DMA driver.
> You can turn on it by write both the dmas and dma-name properties in dts
> node.
> 
> Signed-off-by: Yuan Yao <yao.yuan@freescale.com>
> ---
>  drivers/i2c/busses/i2c-imx.c | 354
> +++++++++++++++++++++++++++++++++++++------ 1 file changed, 306
> insertions(+), 48 deletions(-)

Changelog is missing.

[...]

> +/* Functions for DMA support */
> +static int i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,
> +						dma_addr_t phy_addr)
> +{
> +	struct imx_i2c_dma *dma = i2c_imx->dma;
> +	struct dma_slave_config dma_sconfig;
> +	struct device *dev = &i2c_imx->adapter.dev;
> +	int ret;
> +
> +	dma->chan_tx = dma_request_slave_channel(dev, "tx");
> +	if (!dma->chan_tx) {
> +		dev_err(dev, "Dma tx channel request failed!\n");

DMA is written in all caps, it's an abbrev. for Direct Memory Access . Please 
fix globally.

[...]

>  static int i2c_imx_write(struct imx_i2c_struct *i2c_imx, struct i2c_msg
> *msgs) {

[...]

> -	/* write data */
> -	for (i = 0; i < msgs->len; i++) {
> -		dev_dbg(&i2c_imx->adapter.dev,
> -			"<%s> write byte: B%d=0x%X\n",
> -			__func__, i, msgs->buf[i]);
> -		imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);
> +		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
> +		temp |= I2CR_DMAEN;
> +		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
> +
> +		/* write slave address */
> +		imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);
> +		result = wait_for_completion_interruptible_timeout(
> +					&i2c_imx->dma->cmd_complete,
> +					msecs_to_jiffies(IMX_I2C_DMA_TIMEOUT));
> +		if (result <= 0) {
> +			dmaengine_terminate_all(dma->chan_using);
> +			if (result)
> +				return result;
> +			else
> +				return -ETIMEDOUT;
> +		}
> +
> +		/* waiting for Transfer complete. */
> +		while (timeout--) {
> +			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
> +			if (temp & I2SR_ICF)
> +				break;
> +			udelay(10);
> +		}

Do you ever check if this really timed out and handle such case at all ? I don't 
see it , but I might be wrong ...

> +		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
> +		temp &= ~I2CR_DMAEN;
> +		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
> +
> +		/* write the last byte */
> +		imx_i2c_write_reg(msgs->buf[msgs->len-1],
> +					i2c_imx, IMX_I2C_I2DR);
>  		result = i2c_imx_trx_complete(i2c_imx);
>  		if (result)
>  			return result;
> +
>  		result = i2c_imx_acked(i2c_imx);
>  		if (result)
>  			return result;
> +	} else {
> +		/* write slave address */
> +		imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);
> +		result = i2c_imx_trx_complete(i2c_imx);
> +		if (result)
> +			return result;
> +
> +		result = i2c_imx_acked(i2c_imx);
> +		if (result)
> +			return result;
> +
> +		dev_dbg(&i2c_imx->adapter.dev, "<%s> write data\n", __func__);
> +
> +		/* write data */
> +		for (i = 0; i < msgs->len; i++) {
> +			dev_dbg(&i2c_imx->adapter.dev,
> +				"<%s> write byte: B%d=0x%X\n",
> +				__func__, i, msgs->buf[i]);

Can you not just have a variable $dev here and avoid having such a long noodle 
in the dev_dbg() call ?

> +			imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);
> +			result = i2c_imx_trx_complete(i2c_imx);
> +			if (result)
> +				return result;
> +			result = i2c_imx_acked(i2c_imx);
> +			if (result)
> +				return result;
> +		}
>  	}
>  	return 0;
>  }
[...]

> +		/* waiting for Transfer complete. */
> +		while (timeout--) {
> +			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
> +			if (temp & I2SR_ICF)
> +				break;
> +			udelay(10);
> +		}

Timeout handling here as well ...

[...]

> @@ -696,6 +936,21 @@ static int i2c_imx_probe(struct platform_device *pdev)
>  		i2c_imx->adapter.name);
>  	dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");
> 
> +	/* Init DMA config if support*/
> +	i2c_imx->dma = devm_kzalloc(&pdev->dev, sizeof(struct imx_i2c_dma),
> +					GFP_KERNEL);
> +	if (!i2c_imx->dma) {
> +		dev_info(&pdev->dev,
> +				"can't allocate dma struct faild use dma.\n");

Or just have $dev variable and you won't have to break the line at all ...

> +		i2c_imx->use_dma = false;
> +	} else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr)) {
> +		dev_info(&pdev->dev,
> +				"can't request dma chan, faild use dma.\n");
> +		i2c_imx->use_dma = false;
> +	} else {
> +		i2c_imx->use_dma = true;
> +	}

Can you not just check if i2c_imx->dma is valid pointer or NULL pointer ? Then 
you won't need a separate variable, for this purpose ... right ?
[...]
--
To unsubscribe from this list: send the line "unsubscribe linux-i2c" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Yao Yuan - March 26, 2014, 3:08 a.m.
On Sunday, March 23, 2014 @ 11:50:00 AM, Marek Vasut wrote:
> On Thursday, March 13, 2014 at 02:47:56 AM, Yuan Yao wrote:

> > Add dma support for i2c. This function depend on DMA driver.

> > You can turn on it by write both the dmas and dma-name properties in

> > dts node.

> >

> > Signed-off-by: Yuan Yao <yao.yuan@freescale.com>

> > ---

> >  drivers/i2c/busses/i2c-imx.c | 354

> > +++++++++++++++++++++++++++++++++++++------ 1 file changed, 306

> > insertions(+), 48 deletions(-)

> 

> Changelog is missing.


Sorry for this, Maybe the changelog is in the junk box. It's named "[PATCH v3 0/2] i2c: add DMA support for freescale i2c driver". 

> [...]

> 

> > +/* Functions for DMA support */

> > +static int i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,

> > +						dma_addr_t phy_addr)

> > +{

> > +	struct imx_i2c_dma *dma = i2c_imx->dma;

> > +	struct dma_slave_config dma_sconfig;

> > +	struct device *dev = &i2c_imx->adapter.dev;

> > +	int ret;

> > +

> > +	dma->chan_tx = dma_request_slave_channel(dev, "tx");

> > +	if (!dma->chan_tx) {

> > +		dev_err(dev, "Dma tx channel request failed!\n");

> 

> DMA is written in all caps, it's an abbrev. for Direct Memory Access .

> Please fix globally.

> 


Ok, I will fix it globally.

> [...]

> 

> >  static int i2c_imx_write(struct imx_i2c_struct *i2c_imx, struct

> > i2c_msg

> > *msgs) {

> 

> [...]

> 

> > -	/* write data */

> > -	for (i = 0; i < msgs->len; i++) {

> > -		dev_dbg(&i2c_imx->adapter.dev,

> > -			"<%s> write byte: B%d=0x%X\n",

> > -			__func__, i, msgs->buf[i]);

> > -		imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);

> > +		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);

> > +		temp |= I2CR_DMAEN;

> > +		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);

> > +

> > +		/* write slave address */

> > +		imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);

> > +		result = wait_for_completion_interruptible_timeout(

> > +					&i2c_imx->dma->cmd_complete,

> > +					msecs_to_jiffies(IMX_I2C_DMA_TIMEOUT));

> > +		if (result <= 0) {

> > +			dmaengine_terminate_all(dma->chan_using);

> > +			if (result)

> > +				return result;

> > +			else

> > +				return -ETIMEDOUT;

> > +		}

> > +

> > +		/* waiting for Transfer complete. */

> > +		while (timeout--) {

> > +			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);

> > +			if (temp & I2SR_ICF)

> > +				break;

> > +			udelay(10);

> > +		}

> 

> Do you ever check if this really timed out and handle such case at all ?

> I don't see it , but I might be wrong ...

> 


Oh, It's a bug, Thank you very much.

> > +		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);

> > +		temp &= ~I2CR_DMAEN;

> > +		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);

> > +

> > +		/* write the last byte */

> > +		imx_i2c_write_reg(msgs->buf[msgs->len-1],

> > +					i2c_imx, IMX_I2C_I2DR);

> >  		result = i2c_imx_trx_complete(i2c_imx);

> >  		if (result)

> >  			return result;

> > +

> >  		result = i2c_imx_acked(i2c_imx);

> >  		if (result)

> >  			return result;

> > +	} else {

> > +		/* write slave address */

> > +		imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);

> > +		result = i2c_imx_trx_complete(i2c_imx);

> > +		if (result)

> > +			return result;

> > +

> > +		result = i2c_imx_acked(i2c_imx);

> > +		if (result)

> > +			return result;

> > +

> > +		dev_dbg(&i2c_imx->adapter.dev, "<%s> write data\n", __func__);

> > +

> > +		/* write data */

> > +		for (i = 0; i < msgs->len; i++) {

> > +			dev_dbg(&i2c_imx->adapter.dev,

> > +				"<%s> write byte: B%d=0x%X\n",

> > +				__func__, i, msgs->buf[i]);

> 

> Can you not just have a variable $dev here and avoid having such a long

> noodle in the dev_dbg() call ?

> 


Ok, And I don't think the dev_dbg() is very helpful here now. 

> > +			imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);

> > +			result = i2c_imx_trx_complete(i2c_imx);

> > +			if (result)

> > +				return result;

> > +			result = i2c_imx_acked(i2c_imx);

> > +			if (result)

> > +				return result;

> > +		}

> >  	}

> >  	return 0;

> >  }

> [...]

> 

> > +		/* waiting for Transfer complete. */

> > +		while (timeout--) {

> > +			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);

> > +			if (temp & I2SR_ICF)

> > +				break;

> > +			udelay(10);

> > +		}

> 

> Timeout handling here as well ...

> 

> [...]

> 

> > @@ -696,6 +936,21 @@ static int i2c_imx_probe(struct platform_device

> *pdev)

> >  		i2c_imx->adapter.name);

> >  	dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");

> >

> > +	/* Init DMA config if support*/

> > +	i2c_imx->dma = devm_kzalloc(&pdev->dev, sizeof(struct imx_i2c_dma),

> > +					GFP_KERNEL);

> > +	if (!i2c_imx->dma) {

> > +		dev_info(&pdev->dev,

> > +				"can't allocate dma struct faild use dma.\n");

> 

> Or just have $dev variable and you won't have to break the line at all ...

> 

> > +		i2c_imx->use_dma = false;

> > +	} else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr)) {

> > +		dev_info(&pdev->dev,

> > +				"can't request dma chan, faild use dma.\n");

> > +		i2c_imx->use_dma = false;

> > +	} else {

> > +		i2c_imx->use_dma = true;

> > +	}

> 

> Can you not just check if i2c_imx->dma is valid pointer or NULL pointer ?

> Then you won't need a separate variable, for this purpose ... right ?


Sorry and I think what I know is just to check whether it is NULL.
Then for the second question, maybe there are some other ways, But I think it is more tidy and easier 
understanding for using a separate variable, for this purpose.

> [...]

> 


Best regards,
Yuan Yao
Marek Vasut - March 26, 2014, 3:42 a.m.
On Wednesday, March 26, 2014 at 04:08:27 AM, Yao Yuan wrote:

[...]

> > > +		i2c_imx->use_dma = false;
> > > +	} else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr)) {
> > > +		dev_info(&pdev->dev,
> > > +				"can't request dma chan, faild use dma.\n");
> > > +		i2c_imx->use_dma = false;
> > > +	} else {
> > > +		i2c_imx->use_dma = true;
> > > +	}
> > 
> > Can you not just check if i2c_imx->dma is valid pointer or NULL pointer ?
> > Then you won't need a separate variable, for this purpose ... right ?
> 
> Sorry and I think what I know is just to check whether it is NULL.
> Then for the second question, maybe there are some other ways, But I think
> it is more tidy and easier understanding for using a separate variable,
> for this purpose.

You are just wasting space and duplicating data, unless I am wrong.

Best regards,
Marek Vasut
--
To unsubscribe from this list: send the line "unsubscribe linux-i2c" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Yao Yuan - March 26, 2014, 5:56 a.m.
T24gV2VkbmVzZGF5LCBNYXJjaCAyNiwgMjAxNCBhdCAxMTo0MzoyNyBBTSwgTWFyZWsgVmFzdXQg
d3JvdGU6DQo+IE9uIFdlZG5lc2RheSwgTWFyY2ggMjYsIDIwMTQgYXQgMDQ6MDg6MjcgQU0sIFlh
byBZdWFuIHdyb3RlOg0KPiANCj4gWy4uLl0NCj4gDQo+ID4gPiA+ICsJCWkyY19pbXgtPnVzZV9k
bWEgPSBmYWxzZTsNCj4gPiA+ID4gKwl9IGVsc2UgaWYgKGkyY19pbXhfZG1hX3JlcXVlc3QoaTJj
X2lteCwgKGRtYV9hZGRyX3QpcGh5X2FkZHIpKQ0KPiB7DQo+ID4gPiA+ICsJCWRldl9pbmZvKCZw
ZGV2LT5kZXYsDQo+ID4gPiA+ICsJCQkJImNhbid0IHJlcXVlc3QgZG1hIGNoYW4sIGZhaWxkIHVz
ZSBkbWEuXG4iKTsNCj4gPiA+ID4gKwkJaTJjX2lteC0+dXNlX2RtYSA9IGZhbHNlOw0KPiA+ID4g
PiArCX0gZWxzZSB7DQo+ID4gPiA+ICsJCWkyY19pbXgtPnVzZV9kbWEgPSB0cnVlOw0KPiA+ID4g
PiArCX0NCj4gPiA+DQo+ID4gPiBDYW4geW91IG5vdCBqdXN0IGNoZWNrIGlmIGkyY19pbXgtPmRt
YSBpcyB2YWxpZCBwb2ludGVyIG9yIE5VTEwNCj4gcG9pbnRlciA/DQo+ID4gPiBUaGVuIHlvdSB3
b24ndCBuZWVkIGEgc2VwYXJhdGUgdmFyaWFibGUsIGZvciB0aGlzIHB1cnBvc2UgLi4uIHJpZ2h0
ID8NCj4gPg0KPiA+IFNvcnJ5IGFuZCBJIHRoaW5rIHdoYXQgSSBrbm93IGlzIGp1c3QgdG8gY2hl
Y2sgd2hldGhlciBpdCBpcyBOVUxMLg0KPiA+IFRoZW4gZm9yIHRoZSBzZWNvbmQgcXVlc3Rpb24s
IG1heWJlIHRoZXJlIGFyZSBzb21lIG90aGVyIHdheXMsIEJ1dCBJDQo+ID4gdGhpbmsgaXQgaXMg
bW9yZSB0aWR5IGFuZCBlYXNpZXIgdW5kZXJzdGFuZGluZyBmb3IgdXNpbmcgYSBzZXBhcmF0ZQ0K
PiA+IHZhcmlhYmxlLCBmb3IgdGhpcyBwdXJwb3NlLg0KPiANCj4gWW91IGFyZSBqdXN0IHdhc3Rp
bmcgc3BhY2UgYW5kIGR1cGxpY2F0aW5nIGRhdGEsIHVubGVzcyBJIGFtIHdyb25nLg0KPiANCg0K
V2VsbCwgRG8geW91IGhhdmUgYSBiZXR0ZXIgaWRlYT8gQWx0aG91Z2ggSSB0aGluayBpdCdzIG5l
Y2Vzc2FyeS4NCg0KDQpCZXN0IHJlZ2FyZHMsDQpZdWFuIFlhbw0K
--
To unsubscribe from this list: send the line "unsubscribe linux-i2c" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Marek Vasut - March 26, 2014, 6:26 a.m.
On Wednesday, March 26, 2014 at 06:56:34 AM, Yao Yuan wrote:
> On Wednesday, March 26, 2014 at 11:43:27 AM, Marek Vasut wrote:
> > On Wednesday, March 26, 2014 at 04:08:27 AM, Yao Yuan wrote:
> > 
> > [...]
> > 
> > > > > +		i2c_imx->use_dma = false;
> > > > > +	} else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr))
> > 
> > {
> > 
> > > > > +		dev_info(&pdev->dev,
> > > > > +				"can't request dma chan, faild use dma.
\n");
> > > > > +		i2c_imx->use_dma = false;
> > > > > +	} else {
> > > > > +		i2c_imx->use_dma = true;
> > > > > +	}
> > > > 
> > > > Can you not just check if i2c_imx->dma is valid pointer or NULL
> > 
> > pointer ?
> > 
> > > > Then you won't need a separate variable, for this purpose ... right ?
> > > 
> > > Sorry and I think what I know is just to check whether it is NULL.
> > > Then for the second question, maybe there are some other ways, But I
> > > think it is more tidy and easier understanding for using a separate
> > > variable, for this purpose.
> > 
> > You are just wasting space and duplicating data, unless I am wrong.
> 
> Well, Do you have a better idea? Although I think it's necessary.

I think we disconnected here, sorry. Why can you not use (i2c_imx->dma != NULL) 
instead of (i2c_imx->use_dma == true) please ?

Best regards,
Marek Vasut
--
To unsubscribe from this list: send the line "unsubscribe linux-i2c" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Yao Yuan - March 26, 2014, 7:08 a.m.
On Wednesday, March 26, 2014 at 02:27:46 PM, Marek Vasut wrote:
> On Wednesday, March 26, 2014 at 06:56:34 AM, Yao Yuan wrote:

> > On Wednesday, March 26, 2014 at 11:43:27 AM, Marek Vasut wrote:

> > > On Wednesday, March 26, 2014 at 04:08:27 AM, Yao Yuan wrote:

> > >

> > > [...]

> > >

> > > > > > +		i2c_imx->use_dma = false;

> > > > > > +	} else if (i2c_imx_dma_request(i2c_imx,

> > > > > > +(dma_addr_t)phy_addr))

> > >

> > > {

> > >

> > > > > > +		dev_info(&pdev->dev,

> > > > > > +				"can't request dma chan, faild use dma.

> \n");

> > > > > > +		i2c_imx->use_dma = false;

> > > > > > +	} else {

> > > > > > +		i2c_imx->use_dma = true;

> > > > > > +	}

> > > > >

> > > > > Can you not just check if i2c_imx->dma is valid pointer or NULL

> > >

> > > pointer ?

> > >

> > > > > Then you won't need a separate variable, for this purpose ...

> right ?

> > > >

> > > > Sorry and I think what I know is just to check whether it is NULL.

> > > > Then for the second question, maybe there are some other ways, But

> > > > I think it is more tidy and easier understanding for using a

> > > > separate variable, for this purpose.

> > >

> > > You are just wasting space and duplicating data, unless I am wrong.

> >

> > Well, Do you have a better idea? Although I think it's necessary.

> 

> I think we disconnected here, sorry. Why can you not use (i2c_imx->dma !=

> NULL) instead of (i2c_imx->use_dma == true) please ?

> 


But there are two judge conditions. But only the "i2c_imx->dma", but also whether "i2c_imx_dma_request" success.

"i2c_imx->use_dma == true" be equivalent to "i2c_imx->dma != NULL && !i2c_imx_dma_request()"
Marek Vasut - March 26, 2014, 7:26 a.m.
On Wednesday, March 26, 2014 at 08:08:28 AM, Yao Yuan wrote:
> On Wednesday, March 26, 2014 at 02:27:46 PM, Marek Vasut wrote:
> > On Wednesday, March 26, 2014 at 06:56:34 AM, Yao Yuan wrote:
> > > On Wednesday, March 26, 2014 at 11:43:27 AM, Marek Vasut wrote:
> > > > On Wednesday, March 26, 2014 at 04:08:27 AM, Yao Yuan wrote:
> > > > 
> > > > [...]
> > > > 
> > > > > > > +		i2c_imx->use_dma = false;
> > > > > > > +	} else if (i2c_imx_dma_request(i2c_imx,
> > > > > > > +(dma_addr_t)phy_addr))
> > > > 
> > > > {
> > > > 
> > > > > > > +		dev_info(&pdev->dev,
> > > > > > > +				"can't request dma chan, faild use dma.
> > 
> > \n");
> > 
> > > > > > > +		i2c_imx->use_dma = false;
> > > > > > > +	} else {
> > > > > > > +		i2c_imx->use_dma = true;
> > > > > > > +	}
> > > > > > 
> > > > > > Can you not just check if i2c_imx->dma is valid pointer or NULL
> > > > 
> > > > pointer ?
> > > > 
> > > > > > Then you won't need a separate variable, for this purpose ...
> > 
> > right ?
> > 
> > > > > Sorry and I think what I know is just to check whether it is NULL.
> > > > > Then for the second question, maybe there are some other ways, But
> > > > > I think it is more tidy and easier understanding for using a
> > > > > separate variable, for this purpose.
> > > > 
> > > > You are just wasting space and duplicating data, unless I am wrong.
> > > 
> > > Well, Do you have a better idea? Although I think it's necessary.
> > 
> > I think we disconnected here, sorry. Why can you not use (i2c_imx->dma !=
> > NULL) instead of (i2c_imx->use_dma == true) please ?
> 
> But there are two judge conditions. But only the "i2c_imx->dma", but also
> whether "i2c_imx_dma_request" success.
> 
> "i2c_imx->use_dma == true" be equivalent to "i2c_imx->dma != NULL &&
> !i2c_imx_dma_request()"

+       /* Init DMA config if support*/
+       i2c_imx->dma = devm_kzalloc(&pdev->dev, sizeof(struct imx_i2c_dma),
+                                       GFP_KERNEL);
+       if (!i2c_imx->dma) {
+               dev_info(&pdev->dev,
+                               "can't allocate dma struct faild use dma.\n");
+               i2c_imx->use_dma = false;
+       } else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr)) {
+               dev_info(&pdev->dev,
+                               "can't request dma chan, faild use dma.\n");
+               i2c_imx->use_dma = false;
+       } else {
+               i2c_imx->use_dma = true;
+       }

OK, looking at this one more time, why don't you wrap the allocation of i2c_imx-
>dma into i2c_imx_dma_request() ? Even better, you can allocate *dma as a local 
variable in i2c_imx_dma_request() and then assign it into i2c_imx->dma only at 
the end of the i2c_imx_dma_request() function , at the point where you are sure 
nothing failed. Then you can check i2c_imx->dma != NULL throughout the code to 
check if the DMA is available, no ?

Shawn, Wolfram, am I talking nonsense or am I just not connecting ?

Best regards,
Marek Vasut
--
To unsubscribe from this list: send the line "unsubscribe linux-i2c" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Shawn Guo - April 3, 2014, 7:37 a.m.
On Wed, Mar 26, 2014 at 08:26:27AM +0100, Marek Vasut wrote:
> > > I think we disconnected here, sorry. Why can you not use (i2c_imx->dma !=
> > > NULL) instead of (i2c_imx->use_dma == true) please ?
> > 
> > But there are two judge conditions. But only the "i2c_imx->dma", but also
> > whether "i2c_imx_dma_request" success.
> > 
> > "i2c_imx->use_dma == true" be equivalent to "i2c_imx->dma != NULL &&
> > !i2c_imx_dma_request()"
> 
> +       /* Init DMA config if support*/
> +       i2c_imx->dma = devm_kzalloc(&pdev->dev, sizeof(struct imx_i2c_dma),
> +                                       GFP_KERNEL);
> +       if (!i2c_imx->dma) {
> +               dev_info(&pdev->dev,
> +                               "can't allocate dma struct faild use dma.\n");
> +               i2c_imx->use_dma = false;
> +       } else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr)) {
> +               dev_info(&pdev->dev,
> +                               "can't request dma chan, faild use dma.\n");
> +               i2c_imx->use_dma = false;
> +       } else {
> +               i2c_imx->use_dma = true;
> +       }
> 
> OK, looking at this one more time, why don't you wrap the allocation of i2c_imx-
> >dma into i2c_imx_dma_request() ? Even better, you can allocate *dma as a local 
> variable in i2c_imx_dma_request() and then assign it into i2c_imx->dma only at 
> the end of the i2c_imx_dma_request() function , at the point where you are sure 
> nothing failed. Then you can check i2c_imx->dma != NULL throughout the code to 
> check if the DMA is available, no ?
> 
> Shawn, Wolfram, am I talking nonsense or am I just not connecting ?

I'm with you, Marek.

Shawn

--
To unsubscribe from this list: send the line "unsubscribe linux-i2c" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Patch

diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index db895fb..6bfe23c 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -37,22 +37,27 @@ 
 /** Includes *******************************************************************
 *******************************************************************************/
 
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
+#include <linux/clk.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/dmapool.h>
 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/interrupt.h>
-#include <linux/delay.h>
 #include <linux/i2c.h>
+#include <linux/init.h>
 #include <linux/io.h>
-#include <linux/sched.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/of_dma.h>
 #include <linux/platform_data/i2c-imx.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
 
 /** Defines ********************************************************************
 *******************************************************************************/
@@ -63,6 +68,10 @@ 
 /* Default value */
 #define IMX_I2C_BIT_RATE	100000	/* 100kHz */
 
+/* enable DMA if transfer byte size is bigger than this threshold */
+#define IMX_I2C_DMA_THRESHOLD	16
+#define IMX_I2C_DMA_TIMEOUT	1000
+
 /* IMX I2C registers:
  * the I2C register offset is different between SoCs,
  * to provid support for all these chips, split the
@@ -88,6 +97,7 @@ 
 #define I2SR_IBB	0x20
 #define I2SR_IAAS	0x40
 #define I2SR_ICF	0x80
+#define I2CR_DMAEN	0x02
 #define I2CR_RSTA	0x04
 #define I2CR_TXAK	0x08
 #define I2CR_MTX	0x10
@@ -174,6 +184,17 @@  struct imx_i2c_hwdata {
 	unsigned		i2cr_ien_opcode;
 };
 
+struct imx_i2c_dma {
+	struct dma_chan		*chan_tx;
+	struct dma_chan		*chan_rx;
+	struct dma_chan		*chan_using;
+	struct completion	cmd_complete;
+	dma_addr_t		dma_buf;
+	unsigned int		dma_len;
+	unsigned int		dma_transfer_dir;
+	unsigned int		dma_data_dir;
+};
+
 struct imx_i2c_struct {
 	struct i2c_adapter	adapter;
 	struct clk		*clk;
@@ -184,6 +205,9 @@  struct imx_i2c_struct {
 	int			stopped;
 	unsigned int		ifdr; /* IMX_I2C_IFDR */
 	const struct imx_i2c_hwdata	*hwdata;
+
+	struct imx_i2c_dma	*dma;
+	bool			use_dma;
 };
 
 static const struct imx_i2c_hwdata imx1_i2c_hwdata  = {
@@ -254,9 +278,121 @@  static inline unsigned char imx_i2c_read_reg(struct imx_i2c_struct *i2c_imx,
 	return readb(i2c_imx->base + (reg << i2c_imx->hwdata->regshift));
 }
 
+/* Functions for DMA support */
+static int i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,
+						dma_addr_t phy_addr)
+{
+	struct imx_i2c_dma *dma = i2c_imx->dma;
+	struct dma_slave_config dma_sconfig;
+	struct device *dev = &i2c_imx->adapter.dev;
+	int ret;
+
+	dma->chan_tx = dma_request_slave_channel(dev, "tx");
+	if (!dma->chan_tx) {
+		dev_err(dev, "Dma tx channel request failed!\n");
+		return -ENODEV;
+	}
+
+	dma_sconfig.dst_addr = phy_addr +
+				(IMX_I2C_I2DR << i2c_imx->hwdata->regshift);
+	dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+	dma_sconfig.dst_maxburst = 1;
+	dma_sconfig.direction = DMA_MEM_TO_DEV;
+	ret = dmaengine_slave_config(dma->chan_tx, &dma_sconfig);
+	if (ret < 0) {
+		dev_err(dev, "Dma slave config failed, err = %d\n", ret);
+		goto fail_tx;
+	}
+
+	dma->chan_rx = dma_request_slave_channel(dev, "rx");
+	if (!dma->chan_rx) {
+		dev_err(dev, "Dma rx channel request failed!\n");
+		ret = -ENODEV;
+		goto fail_tx;
+	}
+
+	dma_sconfig.src_addr = phy_addr +
+				(IMX_I2C_I2DR << i2c_imx->hwdata->regshift);
+	dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+	dma_sconfig.src_maxburst = 1;
+	dma_sconfig.direction = DMA_DEV_TO_MEM;
+	ret = dmaengine_slave_config(dma->chan_rx, &dma_sconfig);
+	if (ret < 0) {
+		dev_err(dev, "Dma slave config failed, err = %d\n", ret);
+		goto fail_rx;
+	}
+
+	init_completion(&dma->cmd_complete);
+
+	return 0;
+
+fail_rx:
+	dma_release_channel(dma->chan_rx);
+fail_tx:
+	dma_release_channel(dma->chan_tx);
+	return ret;
+}
+
+static void i2c_imx_dma_callback(void *arg)
+{
+	struct imx_i2c_struct *i2c_imx = (struct imx_i2c_struct *)arg;
+	struct imx_i2c_dma *dma = i2c_imx->dma;
+
+	dma_unmap_single(dma->chan_using->device->dev, dma->dma_buf,
+			dma->dma_len, dma->dma_data_dir);
+	complete(&dma->cmd_complete);
+}
+
+static int i2c_imx_dma_xfer(struct imx_i2c_struct *i2c_imx,
+					struct i2c_msg *msgs)
+{
+	struct imx_i2c_dma *dma = i2c_imx->dma;
+	struct dma_async_tx_descriptor *txdesc;
+	struct device *dev = &i2c_imx->adapter.dev;
+
+	dma->dma_buf = dma_map_single(dma->chan_using->device->dev, msgs->buf,
+					dma->dma_len, dma->dma_data_dir);
+	if (dma_mapping_error(dma->chan_using->device->dev, dma->dma_buf)) {
+		dev_err(dev, "dma_map_single failed\n");
+		return -EINVAL;
+	}
+
+	txdesc = dmaengine_prep_slave_single(dma->chan_using, dma->dma_buf,
+					dma->dma_len, dma->dma_transfer_dir,
+					DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+	if (!txdesc) {
+		dev_err(dev, "Not able to get desc for dma xfer\n");
+		dma_unmap_single(dma->chan_using->device->dev, dma->dma_buf,
+					dma->dma_len, dma->dma_data_dir);
+		return -EINVAL;
+	}
+
+	txdesc->callback = i2c_imx_dma_callback;
+	txdesc->callback_param = i2c_imx;
+	dmaengine_submit(txdesc);
+	dma_async_issue_pending(dma->chan_using);
+
+	return 0;
+}
+
+static void i2c_imx_dma_free(struct imx_i2c_struct *i2c_imx)
+{
+	struct imx_i2c_dma *dma = i2c_imx->dma;
+
+	dma->dma_buf = 0;
+	dma->dma_len = 0;
+
+	dma_release_channel(dma->chan_tx);
+	dma->chan_tx = NULL;
+
+	dma_release_channel(dma->chan_rx);
+	dma->chan_rx = NULL;
+
+	dma->chan_using = NULL;
+}
+
 /** Functions for IMX I2C adapter driver ***************************************
 *******************************************************************************/
-
 static int i2c_imx_bus_busy(struct imx_i2c_struct *i2c_imx, int for_busy)
 {
 	unsigned long orig_jiffies = jiffies;
@@ -427,46 +563,103 @@  static irqreturn_t i2c_imx_isr(int irq, void *dev_id)
 
 static int i2c_imx_write(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs)
 {
-	int i, result;
+	int i, result, timeout = IMX_I2C_DMA_TIMEOUT;
+	unsigned int temp = 0;
+	struct imx_i2c_dma *dma = i2c_imx->dma;
 
 	dev_dbg(&i2c_imx->adapter.dev, "<%s> write slave address: addr=0x%x\n",
 		__func__, msgs->addr << 1);
 
-	/* write slave address */
-	imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);
-	result = i2c_imx_trx_complete(i2c_imx);
-	if (result)
-		return result;
-	result = i2c_imx_acked(i2c_imx);
-	if (result)
-		return result;
-	dev_dbg(&i2c_imx->adapter.dev, "<%s> write data\n", __func__);
+	if (i2c_imx->use_dma && msgs->len >= IMX_I2C_DMA_THRESHOLD) {
+		reinit_completion(&i2c_imx->dma->cmd_complete);
+		dma->chan_using = dma->chan_tx;
+		dma->dma_transfer_dir = DMA_MEM_TO_DEV;
+		dma->dma_data_dir = DMA_TO_DEVICE;
+		dma->dma_len = msgs->len - 1;
+		result = i2c_imx_dma_xfer(i2c_imx, msgs);
+		if (result)
+			return result;
 
-	/* write data */
-	for (i = 0; i < msgs->len; i++) {
-		dev_dbg(&i2c_imx->adapter.dev,
-			"<%s> write byte: B%d=0x%X\n",
-			__func__, i, msgs->buf[i]);
-		imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);
+		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
+		temp |= I2CR_DMAEN;
+		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+
+		/* write slave address */
+		imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);
+		result = wait_for_completion_interruptible_timeout(
+					&i2c_imx->dma->cmd_complete,
+					msecs_to_jiffies(IMX_I2C_DMA_TIMEOUT));
+		if (result <= 0) {
+			dmaengine_terminate_all(dma->chan_using);
+			if (result)
+				return result;
+			else
+				return -ETIMEDOUT;
+		}
+
+		/* waiting for Transfer complete. */
+		while (timeout--) {
+			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
+			if (temp & I2SR_ICF)
+				break;
+			udelay(10);
+		}
+
+		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
+		temp &= ~I2CR_DMAEN;
+		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+
+		/* write the last byte */
+		imx_i2c_write_reg(msgs->buf[msgs->len-1],
+					i2c_imx, IMX_I2C_I2DR);
 		result = i2c_imx_trx_complete(i2c_imx);
 		if (result)
 			return result;
+
 		result = i2c_imx_acked(i2c_imx);
 		if (result)
 			return result;
+	} else {
+		/* write slave address */
+		imx_i2c_write_reg(msgs->addr << 1, i2c_imx, IMX_I2C_I2DR);
+		result = i2c_imx_trx_complete(i2c_imx);
+		if (result)
+			return result;
+
+		result = i2c_imx_acked(i2c_imx);
+		if (result)
+			return result;
+
+		dev_dbg(&i2c_imx->adapter.dev, "<%s> write data\n", __func__);
+
+		/* write data */
+		for (i = 0; i < msgs->len; i++) {
+			dev_dbg(&i2c_imx->adapter.dev,
+				"<%s> write byte: B%d=0x%X\n",
+				__func__, i, msgs->buf[i]);
+			imx_i2c_write_reg(msgs->buf[i], i2c_imx, IMX_I2C_I2DR);
+			result = i2c_imx_trx_complete(i2c_imx);
+			if (result)
+				return result;
+			result = i2c_imx_acked(i2c_imx);
+			if (result)
+				return result;
+		}
 	}
 	return 0;
 }
 
 static int i2c_imx_read(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs)
 {
-	int i, result;
+	int i, result, timeout = IMX_I2C_DMA_TIMEOUT;
 	unsigned int temp;
+	struct imx_i2c_dma *dma = i2c_imx->dma;
 
 	dev_dbg(&i2c_imx->adapter.dev,
 		"<%s> write slave address: addr=0x%x\n",
 		__func__, (msgs->addr << 1) | 0x01);
 
+
 	/* write slave address */
 	imx_i2c_write_reg((msgs->addr << 1) | 0x01, i2c_imx, IMX_I2C_I2DR);
 	result = i2c_imx_trx_complete(i2c_imx);
@@ -488,33 +681,78 @@  static int i2c_imx_read(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs)
 
 	dev_dbg(&i2c_imx->adapter.dev, "<%s> read data\n", __func__);
 
-	/* read data */
-	for (i = 0; i < msgs->len; i++) {
-		result = i2c_imx_trx_complete(i2c_imx);
+	if (i2c_imx->use_dma && msgs->len >= IMX_I2C_DMA_THRESHOLD) {
+		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
+		temp |= I2CR_DMAEN;
+		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+
+		reinit_completion(&i2c_imx->dma->cmd_complete);
+		dma->chan_using = dma->chan_rx;
+		dma->dma_transfer_dir = DMA_DEV_TO_MEM;
+		dma->dma_data_dir = DMA_FROM_DEVICE;
+		dma->dma_len = msgs->len - 2;
+		result = i2c_imx_dma_xfer(i2c_imx, msgs);
 		if (result)
 			return result;
-		if (i == (msgs->len - 1)) {
-			/* It must generate STOP before read I2DR to prevent
-			   controller from generating another clock cycle */
-			dev_dbg(&i2c_imx->adapter.dev,
-				"<%s> clear MSTA\n", __func__);
-			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
-			temp &= ~(I2CR_MSTA | I2CR_MTX);
-			imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
-			i2c_imx_bus_busy(i2c_imx, 0);
-			i2c_imx->stopped = 1;
-		} else if (i == (msgs->len - 2)) {
+
+		result = wait_for_completion_interruptible_timeout(
+					&i2c_imx->dma->cmd_complete,
+					msecs_to_jiffies(IMX_I2C_DMA_TIMEOUT));
+		if (result <= 0) {
+			dmaengine_terminate_all(dma->chan_using);
+			if (result)
+				return result;
+			else
+				return -ETIMEDOUT;
+		}
+
+		/* waiting for Transfer complete. */
+		while (timeout--) {
+			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
+			if (temp & I2SR_ICF)
+				break;
+			udelay(10);
+		}
+
+		temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
+		temp &= ~I2CR_DMAEN;
+		imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+	} else {
+		/* read data */
+		for (i = 0; i < msgs->len - 2; i++) {
+			result = i2c_imx_trx_complete(i2c_imx);
+			if (result)
+				return result;
+			msgs->buf[i] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);
 			dev_dbg(&i2c_imx->adapter.dev,
-				"<%s> set TXAK\n", __func__);
-			temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
-			temp |= I2CR_TXAK;
-			imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+				"<%s> read byte: B%d=0x%X\n",
+				__func__, i, msgs->buf[i]);
 		}
-		msgs->buf[i] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);
-		dev_dbg(&i2c_imx->adapter.dev,
-			"<%s> read byte: B%d=0x%X\n",
-			__func__, i, msgs->buf[i]);
+		result = i2c_imx_trx_complete(i2c_imx);
 	}
+
+	/* read n-1 byte data */
+	temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
+	temp |= I2CR_TXAK;
+	imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+
+	msgs->buf[msgs->len-2] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);
+	/* read n byte data */
+	result = i2c_imx_trx_complete(i2c_imx);
+	if (result)
+		return result;
+
+	/*
+	 * It must generate STOP before read I2DR to prevent
+	 * controller from generating another clock cycle
+	 */
+	temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
+	temp &= ~(I2CR_MSTA | I2CR_MTX);
+	imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
+	i2c_imx_bus_busy(i2c_imx, 0);
+	i2c_imx->stopped = 1;
+	msgs->buf[msgs->len-1] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);
+
 	return 0;
 }
 
@@ -601,6 +839,7 @@  static int i2c_imx_probe(struct platform_device *pdev)
 	void __iomem *base;
 	int irq, ret;
 	u32 bitrate;
+	u32 phy_addr;
 
 	dev_dbg(&pdev->dev, "<%s>\n", __func__);
 
@@ -611,6 +850,7 @@  static int i2c_imx_probe(struct platform_device *pdev)
 	}
 
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	phy_addr = res->start;
 	base = devm_ioremap_resource(&pdev->dev, res);
 	if (IS_ERR(base))
 		return PTR_ERR(base);
@@ -696,6 +936,21 @@  static int i2c_imx_probe(struct platform_device *pdev)
 		i2c_imx->adapter.name);
 	dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");
 
+	/* Init DMA config if support*/
+	i2c_imx->dma = devm_kzalloc(&pdev->dev, sizeof(struct imx_i2c_dma),
+					GFP_KERNEL);
+	if (!i2c_imx->dma) {
+		dev_info(&pdev->dev,
+				"can't allocate dma struct faild use dma.\n");
+		i2c_imx->use_dma = false;
+	} else if (i2c_imx_dma_request(i2c_imx, (dma_addr_t)phy_addr)) {
+		dev_info(&pdev->dev,
+				"can't request dma chan, faild use dma.\n");
+		i2c_imx->use_dma = false;
+	} else {
+		i2c_imx->use_dma = true;
+	}
+
 	return 0;   /* Return OK */
 }
 
@@ -707,6 +962,9 @@  static int i2c_imx_remove(struct platform_device *pdev)
 	dev_dbg(&i2c_imx->adapter.dev, "adapter removed\n");
 	i2c_del_adapter(&i2c_imx->adapter);
 
+	if (i2c_imx->use_dma)
+		i2c_imx_dma_free(i2c_imx);
+
 	/* setup chip registers to defaults */
 	imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IADR);
 	imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IFDR);