[PATCH v7 0/8] Add MCAN Support for Dra76 platform

[PATCH v7 0/8] Add MCAN Support for Dra76 platform

[Faiz Abbas]

This patch series adds support for M_CAN on the TI Dra76
platform. Device tree patches will be sent separately.
A bunch of patches were sent before by
Franklin Cooper <fcooper@ti.com>. I have clubbed the
series together and rebased to the latest kernel.

v7 changes:
Added support for bitrate_max to be read from the netlink
interface.
Moved allocation of netdevice to probe. Cleaned up the
allocator function.
Moved enabling/disabling of clocks to pm_runtime callbacks.
Minor format changes.

patch 5 depends on patch 4 which in turn depends on patch 3.

v6 changes:
Dropped the patches to make hclk optional. Drivers
which enable hclk as the interface clock using
pm_runtime calls must still provide a hclk in the
clocks property.

Support higher speed CAN-FD bitrate:
The community decided that data sampling point be used
for the secondary sampling point here
https://patchwork.kernel.org/patch/9909845/

Faiz Abbas (2):
  can: m_can: Remove check for version when allocating m_can net device
  can: m_can: Move allocation of net device to probe

Franklin S Cooper Jr (6):
  can: dev: Add support for limiting configured bitrate
  can: m_can: Add call to of_can_transceiver
  can: m_can: Add PM Support
  can: m_can: Support higher speed CAN-FD bitrates
  dt-bindings: can: m_can: Document new can transceiver binding
  dt-bindings: can: can-transceiver: Document new binding

 .../bindings/net/can/can-transceiver.txt           |  24 +++
 .../devicetree/bindings/net/can/m_can.txt          |   9 ++
 drivers/net/can/dev.c                              |  45 +++++-
 drivers/net/can/m_can/m_can.c                      | 169 ++++++++++++++-------
 include/linux/can/dev.h                            |   8 +
 include/uapi/linux/can/netlink.h                   |   1 +
 6 files changed, 202 insertions(+), 54 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/net/can/can-transceiver.txt

-- 
2.7.4

[PATCH v7 1/8] can: dev: Add support for limiting configured bitrate

[Faiz Abbas]

From: Franklin S Cooper Jr <fcooper@ti.com>

Various CAN or CAN-FD IP may be able to run at a faster rate than
what the transceiver the CAN node is connected to. This can lead to
unexpected errors. However, CAN transceivers typically have fixed
limitations and provide no means to discover these limitations at
runtime. Therefore, add support for a can-transceiver node that
can be reused by other CAN peripheral drivers to determine for both
CAN and CAN-FD what the max bitrate that can be used. If the user
tries to configure CAN to pass these maximum bitrates it will throw
an error.

Also add support for reading bitrate_max via the netlink interface.

Reviewed-by: Suman Anna <s-anna@ti.com>
Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
[nsekhar@ti.com: fix build error with !CONFIG_OF]
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/net/can/dev.c            | 45 +++++++++++++++++++++++++++++++++++++++-
 include/linux/can/dev.h          |  8 +++++++
 include/uapi/linux/can/netlink.h |  1 +
 3 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
index 365a8cc..c5bc33f 100644
--- a/drivers/net/can/dev.c
+++ b/drivers/net/can/dev.c
@@ -27,6 +27,7 @@
 #include <linux/can/skb.h>
 #include <linux/can/netlink.h>
 #include <linux/can/led.h>
+#include <linux/of.h>
 #include <net/rtnetlink.h>
 
 #define MOD_DESC "CAN device driver interface"
@@ -814,6 +815,29 @@ int open_candev(struct net_device *dev)
 }
 EXPORT_SYMBOL_GPL(open_candev);
 
+#ifdef CONFIG_OF
+/* Common function that can be used to understand the limitation of
+ * a transceiver when it provides no means to determine these limitations
+ * at runtime.
+ */
+void of_can_transceiver(struct net_device *dev)
+{
+	struct device_node *dn;
+	struct can_priv *priv = netdev_priv(dev);
+	struct device_node *np = dev->dev.parent->of_node;
+	int ret;
+
+	dn = of_get_child_by_name(np, "can-transceiver");
+	if (!dn)
+		return;
+
+	ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
+	if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
+		netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
+}
+EXPORT_SYMBOL_GPL(of_can_transceiver);
+#endif
+
 /*
  * Common close function for cleanup before the device gets closed.
  *
@@ -913,6 +937,13 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],
 					priv->bitrate_const_cnt);
 		if (err)
 			return err;
+
+		if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
+			netdev_err(dev, "arbitration bitrate surpasses transceiver capabilities of %d bps\n",
+				   priv->bitrate_max);
+			return -EINVAL;
+		}
+
 		memcpy(&priv->bittiming, &bt, sizeof(bt));
 
 		if (priv->do_set_bittiming) {
@@ -997,6 +1028,13 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],
 					priv->data_bitrate_const_cnt);
 		if (err)
 			return err;
+
+		if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
+			netdev_err(dev, "canfd data bitrate surpasses transceiver capabilities of %d bps\n",
+				   priv->bitrate_max);
+			return -EINVAL;
+		}
+
 		memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
 
 		if (priv->do_set_data_bittiming) {
@@ -1064,6 +1102,7 @@ static size_t can_get_size(const struct net_device *dev)
 	if (priv->data_bitrate_const)				/* IFLA_CAN_DATA_BITRATE_CONST */
 		size += nla_total_size(sizeof(*priv->data_bitrate_const) *
 				       priv->data_bitrate_const_cnt);
+	size += sizeof(priv->bitrate_max);
 
 	return size;
 }
@@ -1121,7 +1160,11 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
 	     nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
 		     sizeof(*priv->data_bitrate_const) *
 		     priv->data_bitrate_const_cnt,
-		     priv->data_bitrate_const))
+		     priv->data_bitrate_const)) ||
+
+	    (nla_put(skb, IFLA_CAN_BITRATE_MAX,
+		     sizeof(priv->bitrate_max),
+		     &priv->bitrate_max))
 	    )
 
 		return -EMSGSIZE;
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 61f1cf2..a199423 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -46,8 +46,10 @@ struct can_priv {
 	unsigned int bitrate_const_cnt;
 	const u32 *data_bitrate_const;
 	unsigned int data_bitrate_const_cnt;
+	u32 bitrate_max;
 	struct can_clock clock;
 
+
 	enum can_state state;
 
 	/* CAN controller features - see include/uapi/linux/can/netlink.h */
@@ -166,6 +168,12 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
 unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
 void can_free_echo_skb(struct net_device *dev, unsigned int idx);
 
+#ifdef CONFIG_OF
+void of_can_transceiver(struct net_device *dev);
+#else
+static inline void of_can_transceiver(struct net_device *dev) { }
+#endif
+
 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf);
 struct sk_buff *alloc_canfd_skb(struct net_device *dev,
 				struct canfd_frame **cfd);
diff --git a/include/uapi/linux/can/netlink.h b/include/uapi/linux/can/netlink.h
index 96710e7..9f56fad4 100644
--- a/include/uapi/linux/can/netlink.h
+++ b/include/uapi/linux/can/netlink.h
@@ -132,6 +132,7 @@ enum {
 	IFLA_CAN_TERMINATION_CONST,
 	IFLA_CAN_BITRATE_CONST,
 	IFLA_CAN_DATA_BITRATE_CONST,
+	IFLA_CAN_BITRATE_MAX,
 	__IFLA_CAN_MAX
 };
 
-- 
2.7.4

Re: [PATCH v7 1/8] can: dev: Add support for limiting configured bitrate

[Marc Kleine-Budde]

[-- Attachment #1.1: Type: text/plain, Size: 6300 bytes --]

On 01/10/2018 11:55 AM, Faiz Abbas wrote:
> From: Franklin S Cooper Jr <fcooper@ti.com>
> 
> Various CAN or CAN-FD IP may be able to run at a faster rate than
> what the transceiver the CAN node is connected to. This can lead to
> unexpected errors. However, CAN transceivers typically have fixed
> limitations and provide no means to discover these limitations at
> runtime. Therefore, add support for a can-transceiver node that
> can be reused by other CAN peripheral drivers to determine for both
> CAN and CAN-FD what the max bitrate that can be used. If the user
> tries to configure CAN to pass these maximum bitrates it will throw
> an error.
> 
> Also add support for reading bitrate_max via the netlink interface.

added to can-next with some minor changes. See inline.

> Reviewed-by: Suman Anna <s-anna@ti.com>
> Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
> [nsekhar@ti.com: fix build error with !CONFIG_OF]
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> ---
>  drivers/net/can/dev.c            | 45 +++++++++++++++++++++++++++++++++++++++-
>  include/linux/can/dev.h          |  8 +++++++
>  include/uapi/linux/can/netlink.h |  1 +
>  3 files changed, 53 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
> index 365a8cc..c5bc33f 100644
> --- a/drivers/net/can/dev.c
> +++ b/drivers/net/can/dev.c
> @@ -27,6 +27,7 @@
>  #include <linux/can/skb.h>
>  #include <linux/can/netlink.h>
>  #include <linux/can/led.h>
> +#include <linux/of.h>
>  #include <net/rtnetlink.h>
>  
>  #define MOD_DESC "CAN device driver interface"
> @@ -814,6 +815,29 @@ int open_candev(struct net_device *dev)
>  }
>  EXPORT_SYMBOL_GPL(open_candev);
>  
> +#ifdef CONFIG_OF
> +/* Common function that can be used to understand the limitation of
> + * a transceiver when it provides no means to determine these limitations
> + * at runtime.
> + */
> +void of_can_transceiver(struct net_device *dev)
> +{
> +	struct device_node *dn;
> +	struct can_priv *priv = netdev_priv(dev);
> +	struct device_node *np = dev->dev.parent->of_node;
> +	int ret;
> +
> +	dn = of_get_child_by_name(np, "can-transceiver");
> +	if (!dn)
> +		return;
> +
> +	ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
> +	if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
> +		netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
> +}
> +EXPORT_SYMBOL_GPL(of_can_transceiver);
> +#endif
> +
>  /*
>   * Common close function for cleanup before the device gets closed.
>   *
> @@ -913,6 +937,13 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],
>  					priv->bitrate_const_cnt);
>  		if (err)
>  			return err;
> +
> +		if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
> +			netdev_err(dev, "arbitration bitrate surpasses transceiver capabilities of %d bps\n",
> +				   priv->bitrate_max);
> +			return -EINVAL;
> +		}
> +
>  		memcpy(&priv->bittiming, &bt, sizeof(bt));
>  
>  		if (priv->do_set_bittiming) {
> @@ -997,6 +1028,13 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[],
>  					priv->data_bitrate_const_cnt);
>  		if (err)
>  			return err;
> +
> +		if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
> +			netdev_err(dev, "canfd data bitrate surpasses transceiver capabilities of %d bps\n",
> +				   priv->bitrate_max);
> +			return -EINVAL;
> +		}
> +
>  		memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
>  
>  		if (priv->do_set_data_bittiming) {
> @@ -1064,6 +1102,7 @@ static size_t can_get_size(const struct net_device *dev)
>  	if (priv->data_bitrate_const)				/* IFLA_CAN_DATA_BITRATE_CONST */
>  		size += nla_total_size(sizeof(*priv->data_bitrate_const) *
>  				       priv->data_bitrate_const_cnt);
> +	size += sizeof(priv->bitrate_max);

Added "mising" comment: /* IFLA_CAN_BITRATE_MAX */

>  
>  	return size;
>  }
> @@ -1121,7 +1160,11 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
>  	     nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
>  		     sizeof(*priv->data_bitrate_const) *
>  		     priv->data_bitrate_const_cnt,
> -		     priv->data_bitrate_const))
> +		     priv->data_bitrate_const)) ||
> +
> +	    (nla_put(skb, IFLA_CAN_BITRATE_MAX,
> +		     sizeof(priv->bitrate_max),
> +		     &priv->bitrate_max))
>  	    )
>  
>  		return -EMSGSIZE;
> diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
> index 61f1cf2..a199423 100644
> --- a/include/linux/can/dev.h
> +++ b/include/linux/can/dev.h
> @@ -46,8 +46,10 @@ struct can_priv {
>  	unsigned int bitrate_const_cnt;
>  	const u32 *data_bitrate_const;
>  	unsigned int data_bitrate_const_cnt;
> +	u32 bitrate_max;
>  	struct can_clock clock;
>  
> +

I've removed this.

>  	enum can_state state;
>  
>  	/* CAN controller features - see include/uapi/linux/can/netlink.h */
> @@ -166,6 +168,12 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
>  unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
>  void can_free_echo_skb(struct net_device *dev, unsigned int idx);
>  
> +#ifdef CONFIG_OF
> +void of_can_transceiver(struct net_device *dev);
> +#else
> +static inline void of_can_transceiver(struct net_device *dev) { }
> +#endif
> +
>  struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf);
>  struct sk_buff *alloc_canfd_skb(struct net_device *dev,
>  				struct canfd_frame **cfd);
> diff --git a/include/uapi/linux/can/netlink.h b/include/uapi/linux/can/netlink.h
> index 96710e7..9f56fad4 100644
> --- a/include/uapi/linux/can/netlink.h
> +++ b/include/uapi/linux/can/netlink.h
> @@ -132,6 +132,7 @@ enum {
>  	IFLA_CAN_TERMINATION_CONST,
>  	IFLA_CAN_BITRATE_CONST,
>  	IFLA_CAN_DATA_BITRATE_CONST,
> +	IFLA_CAN_BITRATE_MAX,
>  	__IFLA_CAN_MAX
>  };
>  
> 

Marc

-- 
Pengutronix e.K.                  | Marc Kleine-Budde           |
Industrial Linux Solutions        | Phone: +49-231-2826-924     |
Vertretung West/Dortmund          | Fax:   +49-5121-206917-5555 |
Amtsgericht Hildesheim, HRA 2686  | http://www.pengutronix.de   |


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

[PATCH v7 2/8] can: m_can: Add call to of_can_transceiver

[Faiz Abbas]

From: Franklin S Cooper Jr <fcooper@ti.com>

Add call to new generic functions that provides support via a binding
to limit the arbitration rate and/or data rate imposed by the physical
transceiver connected to the MCAN peripheral.

Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/net/can/m_can/m_can.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
index f4947a7..f72116e 100644
--- a/drivers/net/can/m_can/m_can.c
+++ b/drivers/net/can/m_can/m_can.c
@@ -1649,6 +1649,8 @@ static int m_can_plat_probe(struct platform_device *pdev)
 
 	devm_can_led_init(dev);
 
+	of_can_transceiver(dev);
+
 	dev_info(&pdev->dev, "%s device registered (irq=%d, version=%d)\n",
 		 KBUILD_MODNAME, dev->irq, priv->version);
 
-- 
2.7.4

[PATCH v7 3/8] can: m_can: Remove check for version when allocating m_can net device

[Faiz Abbas]

Currently the m_can version is used to set the tx_fifo_count to 1 when
allocating the net device. However, this is redundant as a value of 1
for the tx_fifo_count needs to be provided in the bosch,mram-cfg
property of the device tree node anyway.

Therefore, remove check for version when allocating the net device.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/net/can/m_can/m_can.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
index f72116e..893edbb 100644
--- a/drivers/net/can/m_can/m_can.c
+++ b/drivers/net/can/m_can/m_can.c
@@ -1213,7 +1213,6 @@ static struct net_device *alloc_m_can_dev(struct platform_device *pdev,
 	struct net_device *dev;
 	struct m_can_priv *priv;
 	int m_can_version;
-	unsigned int echo_buffer_count;
 
 	m_can_version = m_can_check_core_release(addr);
 	/* return if unsupported version */
@@ -1222,12 +1221,7 @@ static struct net_device *alloc_m_can_dev(struct platform_device *pdev,
 		goto return_dev;
 	}
 
-	/* If version < 3.1.x, then only one echo buffer is used */
-	echo_buffer_count = ((m_can_version == 30)
-				? 1U
-				: (unsigned int)tx_fifo_size);
-
-	dev = alloc_candev(sizeof(*priv), echo_buffer_count);
+	dev = alloc_candev(sizeof(*priv), tx_fifo_size);
 	if (!dev) {
 		dev = NULL;
 		goto return_dev;
-- 
2.7.4

[PATCH v7 4/8] can: m_can: Move allocation of net device to probe

[Faiz Abbas]

With the version no longer required to allocate the net device, it can
be moved to probe and the alloc_m_can_dev() function can be simplified.

Therefore, move the allocation of net device to probe and change
alloc_m_can_dev() to setup_m_can_dev().

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/net/can/m_can/m_can.c | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
index 893edbb..07ebe7f 100644
--- a/drivers/net/can/m_can/m_can.c
+++ b/drivers/net/can/m_can/m_can.c
@@ -1207,25 +1207,20 @@ static bool m_can_niso_supported(const struct m_can_priv *priv)
 	return !niso_timeout;
 }
 
-static struct net_device *alloc_m_can_dev(struct platform_device *pdev,
-					  void __iomem *addr, u32 tx_fifo_size)
+static int setup_m_can_dev(struct platform_device *pdev, struct net_device *dev,
+			   void __iomem *addr)
 {
-	struct net_device *dev;
 	struct m_can_priv *priv;
 	int m_can_version;
 
 	m_can_version = m_can_check_core_release(addr);
 	/* return if unsupported version */
 	if (!m_can_version) {
-		dev = NULL;
-		goto return_dev;
+		dev_err(&pdev->dev, "Unsupported version number: %2d",
+			m_can_version);
+		return -EINVAL;
 	}
 
-	dev = alloc_candev(sizeof(*priv), tx_fifo_size);
-	if (!dev) {
-		dev = NULL;
-		goto return_dev;
-	}
 	priv = netdev_priv(dev);
 	netif_napi_add(dev, &priv->napi, m_can_poll, M_CAN_NAPI_WEIGHT);
 
@@ -1271,12 +1266,10 @@ static struct net_device *alloc_m_can_dev(struct platform_device *pdev,
 		free_m_can_dev(dev);
 		dev_err(&pdev->dev, "Unsupported version number: %2d",
 			priv->version);
-		dev = NULL;
-		break;
+		return -EINVAL;
 	}
 
-return_dev:
-	return dev;
+	return 0;
 }
 
 static int m_can_open(struct net_device *dev)
@@ -1616,11 +1609,16 @@ static int m_can_plat_probe(struct platform_device *pdev)
 	tx_fifo_size = mram_config_vals[7];
 
 	/* allocate the m_can device */
-	dev = alloc_m_can_dev(pdev, addr, tx_fifo_size);
+	dev = alloc_candev(sizeof(*priv), tx_fifo_size);
 	if (!dev) {
 		ret = -ENOMEM;
 		goto disable_cclk_ret;
 	}
+
+	ret = setup_m_can_dev(pdev, dev, addr);
+	if (ret)
+		goto disable_cclk_ret;
+
 	priv = netdev_priv(dev);
 	dev->irq = irq;
 	priv->device = &pdev->dev;
-- 
2.7.4

Re: [PATCH v7 4/8] can: m_can: Move allocation of net device to probe

[Marc Kleine-Budde]

[-- Attachment #1.1: Type: text/plain, Size: 995 bytes --]

On 01/10/2018 11:55 AM, Faiz Abbas wrote:
> With the version no longer required to allocate the net device, it can
> be moved to probe and the alloc_m_can_dev() function can be simplified.
> 
> Therefore, move the allocation of net device to probe and change
> alloc_m_can_dev() to setup_m_can_dev().

The error handling is broken with this patch,

Have a look at the switch (priv->version) in setup_m_can_dev(), you free
the m_can_dev in case of error, but exit with -EINVAL in the beginning
of the function. setup_m_can_dev() should not free if it doesn't allocate.

The error handling in m_can_plat_probe() is broken, too. If
pm_runtime_get_sync(&pdev->dev) fails, you don't free the candev.

Marc

-- 
Pengutronix e.K.                  | Marc Kleine-Budde           |
Industrial Linux Solutions        | Phone: +49-231-2826-924     |
Vertretung West/Dortmund          | Fax:   +49-5121-206917-5555 |
Amtsgericht Hildesheim, HRA 2686  | http://www.pengutronix.de   |


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

Re: [PATCH v7 4/8] can: m_can: Move allocation of net device to probe

[Faiz Abbas]

Hi,

On Monday 15 January 2018 07:22 PM, Marc Kleine-Budde wrote:
> On 01/10/2018 11:55 AM, Faiz Abbas wrote:
>> With the version no longer required to allocate the net device, it can
>> be moved to probe and the alloc_m_can_dev() function can be simplified.
>>
>> Therefore, move the allocation of net device to probe and change
>> alloc_m_can_dev() to setup_m_can_dev().
> 
> The error handling is broken with this patch,
> 
> Have a look at the switch (priv->version) in setup_m_can_dev(), you free
> the m_can_dev in case of error, but exit with -EINVAL in the beginning
> of the function. setup_m_can_dev() should not free if it doesn't allocate.
> 
> The error handling in m_can_plat_probe() is broken, too. If
> pm_runtime_get_sync(&pdev->dev) fails, you don't free the candev.
> 

Will fix.

Thanks,
Faiz

[PATCH v7 5/8] can: m_can: Add PM Support

[Faiz Abbas]

From: Franklin S Cooper Jr <fcooper@ti.com>

Add support for CONFIG_PM which is the new way to handle managing clocks.

Move the clock management to pm_runtime_resume() and pm_runtime_suspend()
callbacks for the driver.

CONFIG_PM is required by OMAP based devices to handle clock management.
Therefore, this allows future Texas Instruments SoCs that have the MCAN IP
to work with this driver.

Reviewed-by: Suman Anna <s-anna@ti.com>
Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
[nsekhar@ti.com: handle pm_runtime_get_sync() failure, fix some bugs]
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/net/can/m_can/m_can.c | 95 ++++++++++++++++++++++++++++---------------
 1 file changed, 62 insertions(+), 33 deletions(-)

diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
index 07ebe7f..f5c5028 100644
--- a/drivers/net/can/m_can/m_can.c
+++ b/drivers/net/can/m_can/m_can.c
@@ -23,6 +23,7 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/iopoll.h>
 #include <linux/can/dev.h>
 
@@ -625,21 +626,16 @@ static int m_can_clk_start(struct m_can_priv *priv)
 {
 	int err;
 
-	err = clk_prepare_enable(priv->hclk);
-	if (err)
-		return err;
-
-	err = clk_prepare_enable(priv->cclk);
+	err = pm_runtime_get_sync(priv->device);
 	if (err)
-		clk_disable_unprepare(priv->hclk);
+		pm_runtime_put_noidle(priv->device);
 
 	return err;
 }
 
 static void m_can_clk_stop(struct m_can_priv *priv)
 {
-	clk_disable_unprepare(priv->cclk);
-	clk_disable_unprepare(priv->hclk);
+	pm_runtime_put_sync(priv->device);
 }
 
 static int m_can_get_berr_counter(const struct net_device *dev,
@@ -1561,37 +1557,26 @@ static int m_can_plat_probe(struct platform_device *pdev)
 		goto failed_ret;
 	}
 
-	/* Enable clocks. Necessary to read Core Release in order to determine
-	 * M_CAN version
-	 */
-	ret = clk_prepare_enable(hclk);
-	if (ret)
-		goto disable_hclk_ret;
-
-	ret = clk_prepare_enable(cclk);
-	if (ret)
-		goto disable_cclk_ret;
-
 	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "m_can");
 	addr = devm_ioremap_resource(&pdev->dev, res);
 	irq = platform_get_irq_byname(pdev, "int0");
 
 	if (IS_ERR(addr) || irq < 0) {
 		ret = -EINVAL;
-		goto disable_cclk_ret;
+		goto failed_ret;
 	}
 
 	/* message ram could be shared */
 	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "message_ram");
 	if (!res) {
 		ret = -ENODEV;
-		goto disable_cclk_ret;
+		goto failed_ret;
 	}
 
 	mram_addr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 	if (!mram_addr) {
 		ret = -ENOMEM;
-		goto disable_cclk_ret;
+		goto failed_ret;
 	}
 
 	/* get message ram configuration */
@@ -1600,7 +1585,7 @@ static int m_can_plat_probe(struct platform_device *pdev)
 					 sizeof(mram_config_vals) / 4);
 	if (ret) {
 		dev_err(&pdev->dev, "Could not get Message RAM configuration.");
-		goto disable_cclk_ret;
+		goto failed_ret;
 	}
 
 	/* Get TX FIFO size
@@ -1612,13 +1597,9 @@ static int m_can_plat_probe(struct platform_device *pdev)
 	dev = alloc_candev(sizeof(*priv), tx_fifo_size);
 	if (!dev) {
 		ret = -ENOMEM;
-		goto disable_cclk_ret;
+		goto failed_ret;
 	}
 
-	ret = setup_m_can_dev(pdev, dev, addr);
-	if (ret)
-		goto disable_cclk_ret;
-
 	priv = netdev_priv(dev);
 	dev->irq = irq;
 	priv->device = &pdev->dev;
@@ -1632,6 +1613,20 @@ static int m_can_plat_probe(struct platform_device *pdev)
 	platform_set_drvdata(pdev, dev);
 	SET_NETDEV_DEV(dev, &pdev->dev);
 
+	/* Enable clocks. Necessary to read Core Release in order to determine
+	 * M_CAN version
+	 */
+	pm_runtime_enable(&pdev->dev);
+	ret = pm_runtime_get_sync(&pdev->dev);
+	if (ret)  {
+		pm_runtime_put_noidle(&pdev->dev);
+		goto pm_runtime_fail;
+	}
+
+	ret = setup_m_can_dev(pdev, dev, addr);
+	if (ret)
+		goto pm_runtime_put;
+
 	ret = register_m_can_dev(dev);
 	if (ret) {
 		dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
@@ -1650,14 +1645,15 @@ static int m_can_plat_probe(struct platform_device *pdev)
 	 * Stop clocks. They will be reactivated once the M_CAN device is opened
 	 */
 
-	goto disable_cclk_ret;
+	goto pm_runtime_put;
 
 failed_free_dev:
 	free_m_can_dev(dev);
-disable_cclk_ret:
-	clk_disable_unprepare(cclk);
-disable_hclk_ret:
-	clk_disable_unprepare(hclk);
+pm_runtime_put:
+	pm_runtime_put_sync(&pdev->dev);
+pm_runtime_fail:
+	if (ret)
+		pm_runtime_disable(&pdev->dev);
 failed_ret:
 	return ret;
 }
@@ -1715,6 +1711,9 @@ static int m_can_plat_remove(struct platform_device *pdev)
 	struct net_device *dev = platform_get_drvdata(pdev);
 
 	unregister_m_can_dev(dev);
+
+	pm_runtime_disable(&pdev->dev);
+
 	platform_set_drvdata(pdev, NULL);
 
 	free_m_can_dev(dev);
@@ -1722,7 +1721,37 @@ static int m_can_plat_remove(struct platform_device *pdev)
 	return 0;
 }
 
+int m_can_runtime_suspend(struct device *dev)
+{
+	struct net_device *ndev = dev_get_drvdata(dev);
+	struct m_can_priv *priv = netdev_priv(ndev);
+
+	clk_disable_unprepare(priv->cclk);
+	clk_disable_unprepare(priv->hclk);
+
+	return 0;
+}
+
+int m_can_runtime_resume(struct device *dev)
+{
+	struct net_device *ndev = dev_get_drvdata(dev);
+	struct m_can_priv *priv = netdev_priv(ndev);
+	int err;
+
+	err = clk_prepare_enable(priv->hclk);
+	if (err)
+		return err;
+
+	err = clk_prepare_enable(priv->cclk);
+	if (err)
+		clk_disable_unprepare(priv->hclk);
+
+	return err;
+}
+
 static const struct dev_pm_ops m_can_pmops = {
+	SET_RUNTIME_PM_OPS(m_can_runtime_suspend,
+			   m_can_runtime_resume, NULL)
 	SET_SYSTEM_SLEEP_PM_OPS(m_can_suspend, m_can_resume)
 };
 
-- 
2.7.4

Re: [PATCH v7 5/8] can: m_can: Add PM Support

[Marc Kleine-Budde]

[-- Attachment #1.1: Type: text/plain, Size: 6654 bytes --]

On 01/10/2018 11:55 AM, Faiz Abbas wrote:
> From: Franklin S Cooper Jr <fcooper@ti.com>
> 
> Add support for CONFIG_PM which is the new way to handle managing clocks.
> 
> Move the clock management to pm_runtime_resume() and pm_runtime_suspend()
> callbacks for the driver.
> 
> CONFIG_PM is required by OMAP based devices to handle clock management.
> Therefore, this allows future Texas Instruments SoCs that have the MCAN IP
> to work with this driver.
> 
> Reviewed-by: Suman Anna <s-anna@ti.com>
> Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
> [nsekhar@ti.com: handle pm_runtime_get_sync() failure, fix some bugs]
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> ---
>  drivers/net/can/m_can/m_can.c | 95 ++++++++++++++++++++++++++++---------------
>  1 file changed, 62 insertions(+), 33 deletions(-)
> 
> diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
> index 07ebe7f..f5c5028 100644
> --- a/drivers/net/can/m_can/m_can.c
> +++ b/drivers/net/can/m_can/m_can.c
> @@ -23,6 +23,7 @@
>  #include <linux/of.h>
>  #include <linux/of_device.h>
>  #include <linux/platform_device.h>
> +#include <linux/pm_runtime.h>
>  #include <linux/iopoll.h>
>  #include <linux/can/dev.h>
>  
> @@ -625,21 +626,16 @@ static int m_can_clk_start(struct m_can_priv *priv)
>  {
>  	int err;
>  
> -	err = clk_prepare_enable(priv->hclk);
> -	if (err)
> -		return err;
> -
> -	err = clk_prepare_enable(priv->cclk);
> +	err = pm_runtime_get_sync(priv->device);
>  	if (err)
> -		clk_disable_unprepare(priv->hclk);
> +		pm_runtime_put_noidle(priv->device);
>  
>  	return err;
>  }
>  
>  static void m_can_clk_stop(struct m_can_priv *priv)
>  {
> -	clk_disable_unprepare(priv->cclk);
> -	clk_disable_unprepare(priv->hclk);
> +	pm_runtime_put_sync(priv->device);
>  }
>  
>  static int m_can_get_berr_counter(const struct net_device *dev,
> @@ -1561,37 +1557,26 @@ static int m_can_plat_probe(struct platform_device *pdev)
>  		goto failed_ret;
>  	}
>  
> -	/* Enable clocks. Necessary to read Core Release in order to determine
> -	 * M_CAN version
> -	 */
> -	ret = clk_prepare_enable(hclk);
> -	if (ret)
> -		goto disable_hclk_ret;
> -
> -	ret = clk_prepare_enable(cclk);
> -	if (ret)
> -		goto disable_cclk_ret;
> -
>  	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "m_can");
>  	addr = devm_ioremap_resource(&pdev->dev, res);
>  	irq = platform_get_irq_byname(pdev, "int0");
>  
>  	if (IS_ERR(addr) || irq < 0) {
>  		ret = -EINVAL;
> -		goto disable_cclk_ret;
> +		goto failed_ret;
>  	}
>  
>  	/* message ram could be shared */
>  	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "message_ram");
>  	if (!res) {
>  		ret = -ENODEV;
> -		goto disable_cclk_ret;
> +		goto failed_ret;
>  	}
>  
>  	mram_addr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
>  	if (!mram_addr) {
>  		ret = -ENOMEM;
> -		goto disable_cclk_ret;
> +		goto failed_ret;
>  	}
>  
>  	/* get message ram configuration */
> @@ -1600,7 +1585,7 @@ static int m_can_plat_probe(struct platform_device *pdev)
>  					 sizeof(mram_config_vals) / 4);
>  	if (ret) {
>  		dev_err(&pdev->dev, "Could not get Message RAM configuration.");
> -		goto disable_cclk_ret;
> +		goto failed_ret;
>  	}
>  
>  	/* Get TX FIFO size
> @@ -1612,13 +1597,9 @@ static int m_can_plat_probe(struct platform_device *pdev)
>  	dev = alloc_candev(sizeof(*priv), tx_fifo_size);
>  	if (!dev) {
>  		ret = -ENOMEM;
> -		goto disable_cclk_ret;
> +		goto failed_ret;
>  	}
>  
> -	ret = setup_m_can_dev(pdev, dev, addr);
> -	if (ret)
> -		goto disable_cclk_ret;
> -
>  	priv = netdev_priv(dev);
>  	dev->irq = irq;
>  	priv->device = &pdev->dev;
> @@ -1632,6 +1613,20 @@ static int m_can_plat_probe(struct platform_device *pdev)
>  	platform_set_drvdata(pdev, dev);
>  	SET_NETDEV_DEV(dev, &pdev->dev);
>  
> +	/* Enable clocks. Necessary to read Core Release in order to determine
> +	 * M_CAN version
> +	 */
> +	pm_runtime_enable(&pdev->dev);
> +	ret = pm_runtime_get_sync(&pdev->dev);

Why don't you make use of m_can_clk_start() here?

> +	if (ret)  {
> +		pm_runtime_put_noidle(&pdev->dev);
> +		goto pm_runtime_fail;
> +	}
> +
> +	ret = setup_m_can_dev(pdev, dev, addr);
> +	if (ret)
> +		goto pm_runtime_put;
> +
>  	ret = register_m_can_dev(dev);
>  	if (ret) {
>  		dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
> @@ -1650,14 +1645,15 @@ static int m_can_plat_probe(struct platform_device *pdev)
>  	 * Stop clocks. They will be reactivated once the M_CAN device is opened
>  	 */
>  
> -	goto disable_cclk_ret;
> +	goto pm_runtime_put;
>  
>  failed_free_dev:
>  	free_m_can_dev(dev);
> -disable_cclk_ret:
> -	clk_disable_unprepare(cclk);
> -disable_hclk_ret:
> -	clk_disable_unprepare(hclk);
> +pm_runtime_put:
> +	pm_runtime_put_sync(&pdev->dev);
> +pm_runtime_fail:
> +	if (ret)
> +		pm_runtime_disable(&pdev->dev);
>  failed_ret:
>  	return ret;
>  }
> @@ -1715,6 +1711,9 @@ static int m_can_plat_remove(struct platform_device *pdev)
>  	struct net_device *dev = platform_get_drvdata(pdev);
>  
>  	unregister_m_can_dev(dev);
> +
> +	pm_runtime_disable(&pdev->dev);
> +
>  	platform_set_drvdata(pdev, NULL);
>  
>  	free_m_can_dev(dev);
> @@ -1722,7 +1721,37 @@ static int m_can_plat_remove(struct platform_device *pdev)
>  	return 0;
>  }
>  
> +int m_can_runtime_suspend(struct device *dev)
> +{
> +	struct net_device *ndev = dev_get_drvdata(dev);
> +	struct m_can_priv *priv = netdev_priv(ndev);
> +
> +	clk_disable_unprepare(priv->cclk);
> +	clk_disable_unprepare(priv->hclk);
> +
> +	return 0;
> +}
> +
> +int m_can_runtime_resume(struct device *dev)
> +{
> +	struct net_device *ndev = dev_get_drvdata(dev);
> +	struct m_can_priv *priv = netdev_priv(ndev);
> +	int err;
> +
> +	err = clk_prepare_enable(priv->hclk);
> +	if (err)
> +		return err;
> +
> +	err = clk_prepare_enable(priv->cclk);
> +	if (err)
> +		clk_disable_unprepare(priv->hclk);
> +
> +	return err;
> +}
> +
>  static const struct dev_pm_ops m_can_pmops = {
> +	SET_RUNTIME_PM_OPS(m_can_runtime_suspend,
> +			   m_can_runtime_resume, NULL)
>  	SET_SYSTEM_SLEEP_PM_OPS(m_can_suspend, m_can_resume)
>  };
>  
> 

Marc

-- 
Pengutronix e.K.                  | Marc Kleine-Budde           |
Industrial Linux Solutions        | Phone: +49-231-2826-924     |
Vertretung West/Dortmund          | Fax:   +49-5121-206917-5555 |
Amtsgericht Hildesheim, HRA 2686  | http://www.pengutronix.de   |


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

Re: [PATCH v7 5/8] can: m_can: Add PM Support

[Faiz Abbas]

Hi,

On Monday 15 January 2018 07:25 PM, Marc Kleine-Budde wrote:
> On 01/10/2018 11:55 AM, Faiz Abbas wrote:
>> From: Franklin S Cooper Jr <fcooper@ti.com>
>>
>> Add support for CONFIG_PM which is the new way to handle managing clocks.
>>
>> Move the clock management to pm_runtime_resume() and pm_runtime_suspend()
>> callbacks for the driver.
>>
>> CONFIG_PM is required by OMAP based devices to handle clock management.
>> Therefore, this allows future Texas Instruments SoCs that have the MCAN IP
>> to work with this driver.
>>
>> Reviewed-by: Suman Anna <s-anna@ti.com>
>> Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
>> [nsekhar@ti.com: handle pm_runtime_get_sync() failure, fix some bugs]
>> Signed-off-by: Sekhar Nori <nsekhar@ti.com>
>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>> ---
>>  drivers/net/can/m_can/m_can.c | 95 ++++++++++++++++++++++++++++---------------
>>  1 file changed, 62 insertions(+), 33 deletions(-)
>>
>> diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
>> index 07ebe7f..f5c5028 100644
>> --- a/drivers/net/can/m_can/m_can.c
>> +++ b/drivers/net/can/m_can/m_can.c
>> @@ -23,6 +23,7 @@
>>  #include <linux/of.h>
>>  #include <linux/of_device.h>
>>  #include <linux/platform_device.h>
>> +#include <linux/pm_runtime.h>
>>  #include <linux/iopoll.h>
>>  #include <linux/can/dev.h>
>>  
>> @@ -625,21 +626,16 @@ static int m_can_clk_start(struct m_can_priv *priv)
>>  {
>>  	int err;
>>  
>> -	err = clk_prepare_enable(priv->hclk);
>> -	if (err)
>> -		return err;
>> -
>> -	err = clk_prepare_enable(priv->cclk);
>> +	err = pm_runtime_get_sync(priv->device);
>>  	if (err)
>> -		clk_disable_unprepare(priv->hclk);
>> +		pm_runtime_put_noidle(priv->device);
>>  
>>  	return err;
>>  }
>>  
>>  static void m_can_clk_stop(struct m_can_priv *priv)
>>  {
>> -	clk_disable_unprepare(priv->cclk);
>> -	clk_disable_unprepare(priv->hclk);
>> +	pm_runtime_put_sync(priv->device);
>>  }
>>  
>>  static int m_can_get_berr_counter(const struct net_device *dev,
>> @@ -1561,37 +1557,26 @@ static int m_can_plat_probe(struct platform_device *pdev)
>>  		goto failed_ret;
>>  	}
>>  
>> -	/* Enable clocks. Necessary to read Core Release in order to determine
>> -	 * M_CAN version
>> -	 */
>> -	ret = clk_prepare_enable(hclk);
>> -	if (ret)
>> -		goto disable_hclk_ret;
>> -
>> -	ret = clk_prepare_enable(cclk);
>> -	if (ret)
>> -		goto disable_cclk_ret;
>> -
>>  	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "m_can");
>>  	addr = devm_ioremap_resource(&pdev->dev, res);
>>  	irq = platform_get_irq_byname(pdev, "int0");
>>  
>>  	if (IS_ERR(addr) || irq < 0) {
>>  		ret = -EINVAL;
>> -		goto disable_cclk_ret;
>> +		goto failed_ret;
>>  	}
>>  
>>  	/* message ram could be shared */
>>  	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "message_ram");
>>  	if (!res) {
>>  		ret = -ENODEV;
>> -		goto disable_cclk_ret;
>> +		goto failed_ret;
>>  	}
>>  
>>  	mram_addr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
>>  	if (!mram_addr) {
>>  		ret = -ENOMEM;
>> -		goto disable_cclk_ret;
>> +		goto failed_ret;
>>  	}
>>  
>>  	/* get message ram configuration */
>> @@ -1600,7 +1585,7 @@ static int m_can_plat_probe(struct platform_device *pdev)
>>  					 sizeof(mram_config_vals) / 4);
>>  	if (ret) {
>>  		dev_err(&pdev->dev, "Could not get Message RAM configuration.");
>> -		goto disable_cclk_ret;
>> +		goto failed_ret;
>>  	}
>>  
>>  	/* Get TX FIFO size
>> @@ -1612,13 +1597,9 @@ static int m_can_plat_probe(struct platform_device *pdev)
>>  	dev = alloc_candev(sizeof(*priv), tx_fifo_size);
>>  	if (!dev) {
>>  		ret = -ENOMEM;
>> -		goto disable_cclk_ret;
>> +		goto failed_ret;
>>  	}
>>  
>> -	ret = setup_m_can_dev(pdev, dev, addr);
>> -	if (ret)
>> -		goto disable_cclk_ret;
>> -
>>  	priv = netdev_priv(dev);
>>  	dev->irq = irq;
>>  	priv->device = &pdev->dev;
>> @@ -1632,6 +1613,20 @@ static int m_can_plat_probe(struct platform_device *pdev)
>>  	platform_set_drvdata(pdev, dev);
>>  	SET_NETDEV_DEV(dev, &pdev->dev);
>>  
>> +	/* Enable clocks. Necessary to read Core Release in order to determine
>> +	 * M_CAN version
>> +	 */
>> +	pm_runtime_enable(&pdev->dev);
>> +	ret = pm_runtime_get_sync(&pdev->dev);
> 
> Why don't you make use of m_can_clk_start() here?
> 

Sure. Will replace.

Thanks,
Faiz

[PATCH v7 6/8] can: m_can: Support higher speed CAN-FD bitrates

[Faiz Abbas]

From: Franklin S Cooper Jr <fcooper@ti.com>

During test transmitting using CAN-FD at high bitrates (> 2 Mbps)
would fail. Scoping the signals I noticed that only a single bit
was being transmitted and with a bit more investigation realized the actual
MCAN IP would go back to initialization mode automatically.

It appears this issue is due to the MCAN needing to use the Transmitter
Delay Compensation Mode with the correct value for the transmitter delay
compensation offset (tdco). What impacts the tdco value isn't 100% clear
but to calculate it you use an equation defined in the MCAN User's Guide.

The user guide mentions that this register needs to be set based on clock
values, secondary sample point and the data bitrate. One of the key
variables that can't automatically be determined is the secondary
sample point (ssp). This ssp is similar to the sp but is specific to this
transmitter delay compensation mode. The guidelines for configuring
ssp is rather vague but via some CAN test it appears for DRA76x that
putting the value same as data sampling point works.

The CAN-CIA's "Bit Time Requirements for CAN FD" paper presented at
the International CAN Conference 2013 indicates that this TDC mode is
only needed for data bit rates above 2.5 Mbps. Therefore, only enable
this mode when the data bit rate is above 2.5 Mbps.

Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/net/can/m_can/m_can.c | 46 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 43 insertions(+), 3 deletions(-)

diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c
index f5c5028..ef69d0e 100644
--- a/drivers/net/can/m_can/m_can.c
+++ b/drivers/net/can/m_can/m_can.c
@@ -127,6 +127,12 @@ enum m_can_mram_cfg {
 #define DBTP_DSJW_SHIFT		0
 #define DBTP_DSJW_MASK		(0xf << DBTP_DSJW_SHIFT)
 
+/* Transmitter Delay Compensation Register (TDCR) */
+#define TDCR_TDCO_SHIFT		8
+#define TDCR_TDCO_MASK		(0x7F << TDCR_TDCO_SHIFT)
+#define TDCR_TDCF_SHIFT		0
+#define TDCR_TDCF_MASK		(0x7F << TDCR_TDCF_SHIFT)
+
 /* Test Register (TEST) */
 #define TEST_LBCK		BIT(4)
 
@@ -983,13 +989,47 @@ static int m_can_set_bittiming(struct net_device *dev)
 	m_can_write(priv, M_CAN_NBTP, reg_btp);
 
 	if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
+		reg_btp = 0;
 		brp = dbt->brp - 1;
 		sjw = dbt->sjw - 1;
 		tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
 		tseg2 = dbt->phase_seg2 - 1;
-		reg_btp = (brp << DBTP_DBRP_SHIFT) | (sjw << DBTP_DSJW_SHIFT) |
-			(tseg1 << DBTP_DTSEG1_SHIFT) |
-			(tseg2 << DBTP_DTSEG2_SHIFT);
+
+		/* TDC is only needed for bitrates beyond 2.5 MBit/s.
+		 * This is mentioned in the "Bit Time Requirements for CAN FD"
+		 * paper presented at the International CAN Conference 2013
+		 */
+		if (dbt->bitrate > 2500000) {
+			u32 tdco, ssp;
+
+			/* Use the same value of secondary sampling point
+			 * as the data sampling point
+			 */
+			ssp = dbt->sample_point;
+
+			/* Equation based on Bosch's M_CAN User Manual's
+			 * Transmitter Delay Compensation Section
+			 */
+			tdco = (priv->can.clock.freq / 1000) *
+			       ssp / dbt->bitrate;
+
+			/* Max valid TDCO value is 127 */
+			if (tdco > 127) {
+				netdev_warn(dev, "TDCO value of %u is beyond maximum. Using maximum possible value\n",
+					    tdco);
+				tdco = 127;
+			}
+
+			reg_btp |= DBTP_TDC;
+			m_can_write(priv, M_CAN_TDCR,
+				    tdco << TDCR_TDCO_SHIFT);
+		}
+
+		reg_btp |= (brp << DBTP_DBRP_SHIFT) |
+			   (sjw << DBTP_DSJW_SHIFT) |
+			   (tseg1 << DBTP_DTSEG1_SHIFT) |
+			   (tseg2 << DBTP_DTSEG2_SHIFT);
+
 		m_can_write(priv, M_CAN_DBTP, reg_btp);
 	}
 
-- 
2.7.4

[PATCH v7 7/8] dt-bindings: can: m_can: Document new can transceiver binding

[Faiz Abbas]

From: Franklin S Cooper Jr <fcooper@ti.com>

Add information regarding can-transceiver binding. This is especially
important for MCAN since the IP allows CAN FD mode to run significantly
faster than what most transceivers are capable of.

Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 Documentation/devicetree/bindings/net/can/m_can.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Documentation/devicetree/bindings/net/can/m_can.txt b/Documentation/devicetree/bindings/net/can/m_can.txt
index 63e9042..ed61438 100644
--- a/Documentation/devicetree/bindings/net/can/m_can.txt
+++ b/Documentation/devicetree/bindings/net/can/m_can.txt
@@ -43,6 +43,11 @@ Required properties:
 			  Please refer to 2.4.1 Message RAM Configuration in
 			  Bosch M_CAN user manual for details.
 
+Optional Subnode:
+- can-transceiver	: Can-transceiver subnode describing maximum speed
+			  that can be used for CAN/CAN-FD modes. See
+			  Documentation/devicetree/bindings/net/can/can-transceiver.txt
+			  for details.
 Example:
 SoC dtsi:
 m_can1: can@20e8000 {
@@ -63,4 +68,8 @@ Board dts:
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_m_can1>;
 	status = "enabled";
+
+	can-transceiver {
+		max-bitrate = <5000000>;
+	};
 };
-- 
2.7.4

Re: [PATCH v7 7/8] dt-bindings: can: m_can: Document new can transceiver binding

[Rob Herring]

On Wed, Jan 10, 2018 at 4:55 AM, Faiz Abbas <faiz_abbas@ti.com> wrote:
> From: Franklin S Cooper Jr <fcooper@ti.com>
>
> Add information regarding can-transceiver binding. This is especially
> important for MCAN since the IP allows CAN FD mode to run significantly
> faster than what most transceivers are capable of.
>
> Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
> Signed-off-by: Sekhar Nori <nsekhar@ti.com>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> ---
>  Documentation/devicetree/bindings/net/can/m_can.txt | 9 +++++++++
>  1 file changed, 9 insertions(+)

Why did you drop my ack from v6?

Rob

Re: [PATCH v7 7/8] dt-bindings: can: m_can: Document new can transceiver binding

[Faiz Abbas]

Hi Rob,

On Friday 12 January 2018 01:50 AM, Rob Herring wrote:
> On Wed, Jan 10, 2018 at 4:55 AM, Faiz Abbas <faiz_abbas@ti.com> wrote:
>> From: Franklin S Cooper Jr <fcooper@ti.com>
>>
>> Add information regarding can-transceiver binding. This is especially
>> important for MCAN since the IP allows CAN FD mode to run significantly
>> faster than what most transceivers are capable of.
>>
>> Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
>> Signed-off-by: Sekhar Nori <nsekhar@ti.com>
>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>> ---
>>  Documentation/devicetree/bindings/net/can/m_can.txt | 9 +++++++++
>>  1 file changed, 9 insertions(+)
> 
> Why did you drop my ack from v6?

Sorry, I missed it. Will make sure its there in future versions.

Thanks,
Faiz

[PATCH v7 8/8] dt-bindings: can: can-transceiver: Document new binding

[Faiz Abbas]

From: Franklin S Cooper Jr <fcooper@ti.com>

Add documentation to describe usage of the new can-transceiver binding.
This new binding is applicable for any CAN device therefore it exists as
its own document.

Signed-off-by: Franklin S Cooper Jr <fcooper@ti.com>
Signed-off-by: Sekhar Nori <nsekhar@ti.com>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 .../bindings/net/can/can-transceiver.txt           | 24 ++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/net/can/can-transceiver.txt

diff --git a/Documentation/devicetree/bindings/net/can/can-transceiver.txt b/Documentation/devicetree/bindings/net/can/can-transceiver.txt
new file mode 100644
index 0000000..0011f53
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/can/can-transceiver.txt
@@ -0,0 +1,24 @@
+Generic CAN transceiver Device Tree binding
+------------------------------
+
+CAN transceiver typically limits the max speed in standard CAN and CAN FD
+modes. Typically these limitations are static and the transceivers themselves
+provide no way to detect this limitation at runtime. For this situation,
+the "can-transceiver" node can be used.
+
+Required Properties:
+ max-bitrate:	a positive non 0 value that determines the max
+		speed that CAN/CAN-FD can run. Any other value
+		will be ignored.
+
+Examples:
+
+Based on Texas Instrument's TCAN1042HGV CAN Transceiver
+
+m_can0 {
+	....
+	can-transceiver {
+		max-bitrate = <5000000>;
+	};
+	...
+};
-- 
2.7.4

Re: [PATCH v7 0/8] Add MCAN Support for Dra76 platform

[Marc Kleine-Budde]

[-- Attachment #1.1: Type: text/plain, Size: 822 bytes --]

On 01/10/2018 11:55 AM, Faiz Abbas wrote:
> This patch series adds support for M_CAN on the TI Dra76
> platform. Device tree patches will be sent separately.
> A bunch of patches were sent before by
> Franklin Cooper <fcooper@ti.com>. I have clubbed the
> series together and rebased to the latest kernel.

I've added patches 1-3 to linux-can-next/testing. But stopped at 4, due
to the problems with the error handling. You can include 1-3 in your
next posting if you like, otherwise I'll takes the ones I've already
applied.

Marc

-- 
Pengutronix e.K.                  | Marc Kleine-Budde           |
Industrial Linux Solutions        | Phone: +49-231-2826-924     |
Vertretung West/Dortmund          | Fax:   +49-5121-206917-5555 |
Amtsgericht Hildesheim, HRA 2686  | http://www.pengutronix.de   |


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]