Merge tag 'linux-can-next-for-3.15-20140307' of git://gitorious.org/linux-can/linux-can-next

Marc Kleine-Budde says:

====================
pull-request: can-next 2014-02-12

this is a pull request of twelve patches for net-next/master.

Alexander Shiyan contributes two patches for the mcp251x, one making
the driver more quiet and the other one improves the compile time
coverage by removing the #ifdef CONFIG_PM_SLEEP. Then two patches for
the flexcan driver by me, one removing the #ifdef CONFIG_PM_SLEEP, too,
the other one making use of platform_get_device_id(). Another patch by
me which converts the janz-ican3 driver to use netdev_<level>(). The
remaining 7 patches are by Oliver Hartkopp, they add CAN FD support to
the netlink configuration interface.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

6 files changed, 172 insertions, 88 deletions

diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
index c0563f183721..c7a260478749 100644
--- a/drivers/net/can/dev.c
+++ b/drivers/net/can/dev.c
@@ -99,10 +99,10 @@ static int can_update_spt(const struct can_bittiming_const *btc,
         return 1000 * (tseg + 1 - *tseg2) / (tseg + 1);
 }
 
-static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
+static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
+                              const struct can_bittiming_const *btc)
 {
         struct can_priv *priv = netdev_priv(dev);
-        const struct can_bittiming_const *btc = priv->bittiming_const;
         long rate, best_rate = 0;
         long best_error = 1000000000, error = 0;
         int best_tseg = 0, best_brp = 0, brp = 0;
@@ -110,9 +110,6 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
         int spt_error = 1000, spt = 0, sampl_pt;
         u64 v64;
 
-        if (!priv->bittiming_const)
-                return -ENOTSUPP;
-
         /* Use CIA recommended sample points */
         if (bt->sample_point) {
                 sampl_pt = bt->sample_point;
@@ -204,7 +201,8 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
         return 0;
 }
 #else /* !CONFIG_CAN_CALC_BITTIMING */
-static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
+static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
+                              const struct can_bittiming_const *btc)
 {
         netdev_err(dev, "bit-timing calculation not available\n");
         return -EINVAL;
@@ -217,16 +215,13 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
  * prescaler value brp. You can find more information in the header
  * file linux/can/netlink.h.
  */
-static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt)
+static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt,
+                               const struct can_bittiming_const *btc)
 {
         struct can_priv *priv = netdev_priv(dev);
-        const struct can_bittiming_const *btc = priv->bittiming_const;
         int tseg1, alltseg;
         u64 brp64;
 
-        if (!priv->bittiming_const)
-                return -ENOTSUPP;
-
         tseg1 = bt->prop_seg + bt->phase_seg1;
         if (!bt->sjw)
                 bt->sjw = 1;
@@ -254,26 +249,29 @@ static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt)
         return 0;
 }
 
-static int can_get_bittiming(struct net_device *dev, struct can_bittiming *bt)
+static int can_get_bittiming(struct net_device *dev, struct can_bittiming *bt,
+                             const struct can_bittiming_const *btc)
 {
-        struct can_priv *priv = netdev_priv(dev);
         int err;
 
         /* Check if the CAN device has bit-timing parameters */
-        if (priv->bittiming_const) {
+        if (!btc)
+                return -ENOTSUPP;
 
-                /* Non-expert mode? Check if the bitrate has been pre-defined */
-                if (!bt->tq)
-                        /* Determine bit-timing parameters */
-                        err = can_calc_bittiming(dev, bt);
-                else
-                        /* Check bit-timing params and calculate proper brp */
-                        err = can_fixup_bittiming(dev, bt);
-                if (err)
-                        return err;
-        }
+        /*
+         * Depending on the given can_bittiming parameter structure the CAN
+         * timing parameters are calculated based on the provided bitrate OR
+         * alternatively the CAN timing parameters (tq, prop_seg, etc.) are
+         * provided directly which are then checked and fixed up.
+         */
+        if (!bt->tq && bt->bitrate)
+                err = can_calc_bittiming(dev, bt, btc);
+        else if (bt->tq && !bt->bitrate)
+                err = can_fixup_bittiming(dev, bt, btc);
+        else
+                err = -EINVAL;
 
-        return 0;
+        return err;
 }
 
 /*
@@ -317,7 +315,9 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
         BUG_ON(idx >= priv->echo_skb_max);
 
         /* check flag whether this packet has to be looped back */
-        if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK) {
+        if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK ||
+            (skb->protocol != htons(ETH_P_CAN) &&
+             skb->protocol != htons(ETH_P_CANFD))) {
                 kfree_skb(skb);
                 return;
         }
@@ -329,7 +329,6 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
                         return;
 
                 /* make settings for echo to reduce code in irq context */
-                skb->protocol = htons(ETH_P_CAN);
                 skb->pkt_type = PACKET_BROADCAST;
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
                 skb->dev = dev;
@@ -596,6 +595,39 @@ void free_candev(struct net_device *dev)
 EXPORT_SYMBOL_GPL(free_candev);
 
 /*
+ * changing MTU and control mode for CAN/CANFD devices
+ */
+int can_change_mtu(struct net_device *dev, int new_mtu)
+{
+        struct can_priv *priv = netdev_priv(dev);
+
+        /* Do not allow changing the MTU while running */
+        if (dev->flags & IFF_UP)
+                return -EBUSY;
+
+        /* allow change of MTU according to the CANFD ability of the device */
+        switch (new_mtu) {
+        case CAN_MTU:
+                priv->ctrlmode &= ~CAN_CTRLMODE_FD;
+                break;
+
+        case CANFD_MTU:
+                if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD))
+                        return -EINVAL;
+
+                priv->ctrlmode |= CAN_CTRLMODE_FD;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        dev->mtu = new_mtu;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(can_change_mtu);
+
+/*
  * Common open function when the device gets opened.
  *
  * This function should be called in the open function of the device
@@ -605,11 +637,19 @@ int open_candev(struct net_device *dev)
 {
         struct can_priv *priv = netdev_priv(dev);
 
-        if (!priv->bittiming.tq && !priv->bittiming.bitrate) {
+        if (!priv->bittiming.bitrate) {
                 netdev_err(dev, "bit-timing not yet defined\n");
                 return -EINVAL;
         }
 
+        /* For CAN FD the data bitrate has to be >= the arbitration bitrate */
+        if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&
+            (!priv->data_bittiming.bitrate ||
+             (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) {
+                netdev_err(dev, "incorrect/missing data bit-timing\n");
+                return -EINVAL;
+        }
+
         /* Switch carrier on if device was stopped while in bus-off state */
         if (!netif_carrier_ok(dev))
                 netif_carrier_on(dev);
@@ -648,6 +688,10 @@ static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
                                 = { .len = sizeof(struct can_bittiming_const) },
         [IFLA_CAN_CLOCK]        = { .len = sizeof(struct can_clock) },
         [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
+        [IFLA_CAN_DATA_BITTIMING]
+                                = { .len = sizeof(struct can_bittiming) },
+        [IFLA_CAN_DATA_BITTIMING_CONST]
+                                = { .len = sizeof(struct can_bittiming_const) },
 };
 
 static int can_changelink(struct net_device *dev,
@@ -666,9 +710,7 @@ static int can_changelink(struct net_device *dev,
                 if (dev->flags & IFF_UP)
                         return -EBUSY;
                 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
-                if ((!bt.bitrate && !bt.tq) || (bt.bitrate && bt.tq))
-                        return -EINVAL;
-                err = can_get_bittiming(dev, &bt);
+                err = can_get_bittiming(dev, &bt, priv->bittiming_const);
                 if (err)
                         return err;
                 memcpy(&priv->bittiming, &bt, sizeof(bt));
@@ -692,6 +734,12 @@ static int can_changelink(struct net_device *dev,
                         return -EOPNOTSUPP;
                 priv->ctrlmode &= ~cm->mask;
                 priv->ctrlmode |= cm->flags;
+
+                /* CAN_CTRLMODE_FD can only be set when driver supports FD */
+                if (priv->ctrlmode & CAN_CTRLMODE_FD)
+                        dev->mtu = CANFD_MTU;
+                else
+                        dev->mtu = CAN_MTU;
         }
 
         if (data[IFLA_CAN_RESTART_MS]) {
@@ -710,6 +758,27 @@ static int can_changelink(struct net_device *dev,
                         return err;
         }
 
+        if (data[IFLA_CAN_DATA_BITTIMING]) {
+                struct can_bittiming dbt;
+
+                /* Do not allow changing bittiming while running */
+                if (dev->flags & IFF_UP)
+                        return -EBUSY;
+                memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
+                       sizeof(dbt));
+                err = can_get_bittiming(dev, &dbt, priv->data_bittiming_const);
+                if (err)
+                        return err;
+                memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
+
+                if (priv->do_set_data_bittiming) {
+                        /* Finally, set the bit-timing registers */
+                        err = priv->do_set_data_bittiming(dev);
+                        if (err)
+                                return err;
+                }
+        }
+
         return 0;
 }
 
@@ -718,7 +787,8 @@ static size_t can_get_size(const struct net_device *dev)
         struct can_priv *priv = netdev_priv(dev);
         size_t size = 0;
 
-        size += nla_total_size(sizeof(struct can_bittiming));   /* IFLA_CAN_BITTIMING */
+        if (priv->bittiming.bitrate)                            /* IFLA_CAN_BITTIMING */
+                size += nla_total_size(sizeof(struct can_bittiming));
         if (priv->bittiming_const)                              /* IFLA_CAN_BITTIMING_CONST */
                 size += nla_total_size(sizeof(struct can_bittiming_const));
         size += nla_total_size(sizeof(struct can_clock));       /* IFLA_CAN_CLOCK */
@@ -727,6 +797,10 @@ static size_t can_get_size(const struct net_device *dev)
         size += nla_total_size(sizeof(u32));                    /* IFLA_CAN_RESTART_MS */
         if (priv->do_get_berr_counter)                          /* IFLA_CAN_BERR_COUNTER */
                 size += nla_total_size(sizeof(struct can_berr_counter));
+        if (priv->data_bittiming.bitrate)                       /* IFLA_CAN_DATA_BITTIMING */
+                size += nla_total_size(sizeof(struct can_bittiming));
+        if (priv->data_bittiming_const)                         /* IFLA_CAN_DATA_BITTIMING_CONST */
+                size += nla_total_size(sizeof(struct can_bittiming_const));
 
         return size;
 }
@@ -740,19 +814,34 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
 
         if (priv->do_get_state)
                 priv->do_get_state(dev, &state);
-        if (nla_put(skb, IFLA_CAN_BITTIMING,
-                    sizeof(priv->bittiming), &priv->bittiming) ||
+
+        if ((priv->bittiming.bitrate &&
+             nla_put(skb, IFLA_CAN_BITTIMING,
+                     sizeof(priv->bittiming), &priv->bittiming)) ||
+
             (priv->bittiming_const &&
              nla_put(skb, IFLA_CAN_BITTIMING_CONST,
                      sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
+
             nla_put(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock) ||
             nla_put_u32(skb, IFLA_CAN_STATE, state) ||
             nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
             nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
+
             (priv->do_get_berr_counter &&
              !priv->do_get_berr_counter(dev, &bec) &&
-             nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)))
+             nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
+
+            (priv->data_bittiming.bitrate &&
+             nla_put(skb, IFLA_CAN_DATA_BITTIMING,
+                     sizeof(priv->data_bittiming), &priv->data_bittiming)) ||
+
+            (priv->data_bittiming_const &&
+             nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
+                     sizeof(*priv->data_bittiming_const),
+                     priv->data_bittiming_const)))
                 return -EMSGSIZE;
+
         return 0;
 }
 
diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c
index 61376abdab39..c94d698b73c2 100644
--- a/drivers/net/can/flexcan.c
+++ b/drivers/net/can/flexcan.c
@@ -1132,9 +1132,9 @@ static int flexcan_probe(struct platform_device *pdev)
         of_id = of_match_device(flexcan_of_match, &pdev->dev);
         if (of_id) {
                 devtype_data = of_id->data;
-        } else if (pdev->id_entry->driver_data) {
+        } else if (platform_get_device_id(pdev)->driver_data) {
                 devtype_data = (struct flexcan_devtype_data *)
-                        pdev->id_entry->driver_data;
+                        platform_get_device_id(pdev)->driver_data;
         } else {
                 return -ENODEV;
         }
@@ -1201,8 +1201,7 @@ static int flexcan_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int flexcan_suspend(struct device *device)
+static int __maybe_unused flexcan_suspend(struct device *device)
 {
         struct net_device *dev = dev_get_drvdata(device);
         struct flexcan_priv *priv = netdev_priv(dev);
@@ -1221,7 +1220,7 @@ static int flexcan_suspend(struct device *device)
         return 0;
 }
 
-static int flexcan_resume(struct device *device)
+static int __maybe_unused flexcan_resume(struct device *device)
 {
         struct net_device *dev = dev_get_drvdata(device);
         struct flexcan_priv *priv = netdev_priv(dev);
@@ -1233,7 +1232,6 @@ static int flexcan_resume(struct device *device)
         }
         return flexcan_chip_enable(priv);
 }
-#endif /* CONFIG_PM_SLEEP */
 
 static SIMPLE_DEV_PM_OPS(flexcan_pm_ops, flexcan_suspend, flexcan_resume);
 
diff --git a/drivers/net/can/janz-ican3.c b/drivers/net/can/janz-ican3.c
index 71594e5676fd..b47df5e482fa 100644
--- a/drivers/net/can/janz-ican3.c
+++ b/drivers/net/can/janz-ican3.c
@@ -198,9 +198,6 @@ struct ican3_dev {
         struct net_device *ndev;
         struct napi_struct napi;
 
-        /* Device for printing */
-        struct device *dev;
-
         /* module number */
         unsigned int num;
 
@@ -295,7 +292,7 @@ static int ican3_old_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
         xord = locl ^ peer;
 
         if ((xord & MSYNC_RB_MASK) == 0x00) {
-                dev_dbg(mod->dev, "no mbox for reading\n");
+                netdev_dbg(mod->ndev, "no mbox for reading\n");
                 return -ENOMEM;
         }
 
@@ -340,7 +337,7 @@ static int ican3_old_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
         xord = locl ^ peer;
 
         if ((xord & MSYNC_WB_MASK) == MSYNC_WB_MASK) {
-                dev_err(mod->dev, "no mbox for writing\n");
+                netdev_err(mod->ndev, "no mbox for writing\n");
                 return -ENOMEM;
         }
 
@@ -542,7 +539,7 @@ static int ican3_new_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
         memcpy_fromio(&desc, desc_addr, sizeof(desc));
 
         if (!(desc.control & DESC_VALID)) {
-                dev_dbg(mod->dev, "%s: no free buffers\n", __func__);
+                netdev_dbg(mod->ndev, "%s: no free buffers\n", __func__);
                 return -ENOMEM;
         }
 
@@ -573,7 +570,7 @@ static int ican3_new_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
         memcpy_fromio(&desc, desc_addr, sizeof(desc));
 
         if (!(desc.control & DESC_VALID)) {
-                dev_dbg(mod->dev, "%s: no buffers to recv\n", __func__);
+                netdev_dbg(mod->ndev, "%s: no buffers to recv\n", __func__);
                 return -ENOMEM;
         }
 
@@ -883,7 +880,7 @@ static void can_frame_to_ican3(struct ican3_dev *mod,
  */
 static void ican3_handle_idvers(struct ican3_dev *mod, struct ican3_msg *msg)
 {
-        dev_dbg(mod->dev, "IDVERS response: %s\n", msg->data);
+        netdev_dbg(mod->ndev, "IDVERS response: %s\n", msg->data);
 }
 
 static void ican3_handle_msglost(struct ican3_dev *mod, struct ican3_msg *msg)
@@ -899,7 +896,7 @@ static void ican3_handle_msglost(struct ican3_dev *mod, struct ican3_msg *msg)
          * error frame for userspace
          */
         if (msg->spec == MSG_MSGLOST) {
-                dev_err(mod->dev, "lost %d control messages\n", msg->data[0]);
+                netdev_err(mod->ndev, "lost %d control messages\n", msg->data[0]);
                 return;
         }
 
@@ -939,13 +936,13 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
 
         /* we can only handle the SJA1000 part */
         if (msg->data[1] != CEVTIND_CHIP_SJA1000) {
-                dev_err(mod->dev, "unable to handle errors on non-SJA1000\n");
+                netdev_err(mod->ndev, "unable to handle errors on non-SJA1000\n");
                 return -ENODEV;
         }
 
         /* check the message length for sanity */
         if (le16_to_cpu(msg->len) < 6) {
-                dev_err(mod->dev, "error message too short\n");
+                netdev_err(mod->ndev, "error message too short\n");
                 return -EINVAL;
         }
 
@@ -967,7 +964,7 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
          */
         if (isrc == CEVTIND_BEI) {
                 int ret;
-                dev_dbg(mod->dev, "bus error interrupt\n");
+                netdev_dbg(mod->ndev, "bus error interrupt\n");
 
                 /* TX error */
                 if (!(ecc & ECC_DIR)) {
@@ -983,7 +980,7 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
                  */
                 ret = ican3_set_buserror(mod, 1);
                 if (ret) {
-                        dev_err(mod->dev, "unable to re-enable bus-error\n");
+                        netdev_err(mod->ndev, "unable to re-enable bus-error\n");
                         return ret;
                 }
 
@@ -998,7 +995,7 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
 
         /* data overrun interrupt */
         if (isrc == CEVTIND_DOI || isrc == CEVTIND_LOST) {
-                dev_dbg(mod->dev, "data overrun interrupt\n");
+                netdev_dbg(mod->ndev, "data overrun interrupt\n");
                 cf->can_id |= CAN_ERR_CRTL;
                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
                 stats->rx_over_errors++;
@@ -1007,7 +1004,7 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
 
         /* error warning + passive interrupt */
         if (isrc == CEVTIND_EI) {
-                dev_dbg(mod->dev, "error warning + passive interrupt\n");
+                netdev_dbg(mod->ndev, "error warning + passive interrupt\n");
                 if (status & SR_BS) {
                         state = CAN_STATE_BUS_OFF;
                         cf->can_id |= CAN_ERR_BUSOFF;
@@ -1088,7 +1085,7 @@ static void ican3_handle_inquiry(struct ican3_dev *mod, struct ican3_msg *msg)
                 complete(&mod->termination_comp);
                 break;
         default:
-                dev_err(mod->dev, "received an unknown inquiry response\n");
+                netdev_err(mod->ndev, "received an unknown inquiry response\n");
                 break;
         }
 }
@@ -1096,7 +1093,7 @@ static void ican3_handle_inquiry(struct ican3_dev *mod, struct ican3_msg *msg)
 static void ican3_handle_unknown_message(struct ican3_dev *mod,
                                         struct ican3_msg *msg)
 {
-        dev_warn(mod->dev, "received unknown message: spec 0x%.2x length %d\n",
+        netdev_warn(mod->ndev, "received unknown message: spec 0x%.2x length %d\n",
                            msg->spec, le16_to_cpu(msg->len));
 }
 
@@ -1105,7 +1102,7 @@ static void ican3_handle_unknown_message(struct ican3_dev *mod,
  */
 static void ican3_handle_message(struct ican3_dev *mod, struct ican3_msg *msg)
 {
-        dev_dbg(mod->dev, "%s: modno %d spec 0x%.2x len %d bytes\n", __func__,
+        netdev_dbg(mod->ndev, "%s: modno %d spec 0x%.2x len %d bytes\n", __func__,
                            mod->num, msg->spec, le16_to_cpu(msg->len));
 
         switch (msg->spec) {
@@ -1406,7 +1403,7 @@ static int ican3_reset_module(struct ican3_dev *mod)
                 msleep(10);
         } while (time_before(jiffies, start + HZ / 4));
 
-        dev_err(mod->dev, "failed to reset CAN module\n");
+        netdev_err(mod->ndev, "failed to reset CAN module\n");
         return -ETIMEDOUT;
 }
 
@@ -1425,7 +1422,7 @@ static int ican3_startup_module(struct ican3_dev *mod)
 
         ret = ican3_reset_module(mod);
         if (ret) {
-                dev_err(mod->dev, "unable to reset module\n");
+                netdev_err(mod->ndev, "unable to reset module\n");
                 return ret;
         }
 
@@ -1434,41 +1431,41 @@ static int ican3_startup_module(struct ican3_dev *mod)
 
         ret = ican3_msg_connect(mod);
         if (ret) {
-                dev_err(mod->dev, "unable to connect to module\n");
+                netdev_err(mod->ndev, "unable to connect to module\n");
                 return ret;
         }
 
         ican3_init_new_host_interface(mod);
         ret = ican3_msg_newhostif(mod);
         if (ret) {
-                dev_err(mod->dev, "unable to switch to new-style interface\n");
+                netdev_err(mod->ndev, "unable to switch to new-style interface\n");
                 return ret;
         }
 
         /* default to "termination on" */
         ret = ican3_set_termination(mod, true);
         if (ret) {
-                dev_err(mod->dev, "unable to enable termination\n");
+                netdev_err(mod->ndev, "unable to enable termination\n");
                 return ret;
         }
 
         /* default to "bus errors enabled" */
         ret = ican3_set_buserror(mod, 1);
         if (ret) {
-                dev_err(mod->dev, "unable to set bus-error\n");
+                netdev_err(mod->ndev, "unable to set bus-error\n");
                 return ret;
         }
 
         ican3_init_fast_host_interface(mod);
         ret = ican3_msg_fasthostif(mod);
         if (ret) {
-                dev_err(mod->dev, "unable to switch to fast host interface\n");
+                netdev_err(mod->ndev, "unable to switch to fast host interface\n");
                 return ret;
         }
 
         ret = ican3_set_id_filter(mod, true);
         if (ret) {
-                dev_err(mod->dev, "unable to set acceptance filter\n");
+                netdev_err(mod->ndev, "unable to set acceptance filter\n");
                 return ret;
         }
 
@@ -1487,14 +1484,14 @@ static int ican3_open(struct net_device *ndev)
         /* open the CAN layer */
         ret = open_candev(ndev);
         if (ret) {
-                dev_err(mod->dev, "unable to start CAN layer\n");
+                netdev_err(mod->ndev, "unable to start CAN layer\n");
                 return ret;
         }
 
         /* bring the bus online */
         ret = ican3_set_bus_state(mod, true);
         if (ret) {
-                dev_err(mod->dev, "unable to set bus-on\n");
+                netdev_err(mod->ndev, "unable to set bus-on\n");
                 close_candev(ndev);
                 return ret;
         }
@@ -1518,7 +1515,7 @@ static int ican3_stop(struct net_device *ndev)
         /* bring the bus offline, stop receiving packets */
         ret = ican3_set_bus_state(mod, false);
         if (ret) {
-                dev_err(mod->dev, "unable to set bus-off\n");
+                netdev_err(mod->ndev, "unable to set bus-off\n");
                 return ret;
         }
 
@@ -1545,7 +1542,7 @@ static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev)
 
         /* check that we can actually transmit */
         if (!ican3_txok(mod)) {
-                dev_err(mod->dev, "BUG: no free descriptors\n");
+                netdev_err(mod->ndev, "BUG: no free descriptors\n");
                 spin_unlock_irqrestore(&mod->lock, flags);
                 return NETDEV_TX_BUSY;
         }
@@ -1657,7 +1654,7 @@ static int ican3_set_mode(struct net_device *ndev, enum can_mode mode)
         /* bring the bus online */
         ret = ican3_set_bus_state(mod, true);
         if (ret) {
-                dev_err(mod->dev, "unable to set bus-on\n");
+                netdev_err(ndev, "unable to set bus-on\n");
                 return ret;
         }
 
@@ -1682,7 +1679,7 @@ static int ican3_get_berr_counter(const struct net_device *ndev,
 
         ret = wait_for_completion_timeout(&mod->buserror_comp, HZ);
         if (ret == 0) {
-                dev_info(mod->dev, "%s timed out\n", __func__);
+                netdev_info(mod->ndev, "%s timed out\n", __func__);
                 return -ETIMEDOUT;
         }
 
@@ -1708,7 +1705,7 @@ static ssize_t ican3_sysfs_show_term(struct device *dev,
 
         ret = wait_for_completion_timeout(&mod->termination_comp, HZ);
         if (ret == 0) {
-                dev_info(mod->dev, "%s timed out\n", __func__);
+                netdev_info(mod->ndev, "%s timed out\n", __func__);
                 return -ETIMEDOUT;
         }
 
@@ -1778,7 +1775,6 @@ static int ican3_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, ndev);
         mod = netdev_priv(ndev);
         mod->ndev = ndev;
-        mod->dev = &pdev->dev;
         mod->num = pdata->modno;
         netif_napi_add(ndev, &mod->napi, ican3_napi, ICAN3_RX_BUFFERS);
         skb_queue_head_init(&mod->echoq);
diff --git a/drivers/net/can/mcp251x.c b/drivers/net/can/mcp251x.c
index cdb9808d12db..50aa630c7dd4 100644
--- a/drivers/net/can/mcp251x.c
+++ b/drivers/net/can/mcp251x.c
@@ -601,10 +601,10 @@ static int mcp251x_do_set_bittiming(struct net_device *net)
                           (bt->prop_seg - 1));
         mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK,
                            (bt->phase_seg2 - 1));
-        dev_info(&spi->dev, "CNF: 0x%02x 0x%02x 0x%02x\n",
-                 mcp251x_read_reg(spi, CNF1),
-                 mcp251x_read_reg(spi, CNF2),
-                 mcp251x_read_reg(spi, CNF3));
+        dev_dbg(&spi->dev, "CNF: 0x%02x 0x%02x 0x%02x\n",
+                mcp251x_read_reg(spi, CNF1),
+                mcp251x_read_reg(spi, CNF2),
+                mcp251x_read_reg(spi, CNF3));
 
         return 0;
 }
@@ -1155,8 +1155,6 @@ static int mcp251x_can_probe(struct spi_device *spi)
 
         devm_can_led_init(net);
 
-        dev_info(&spi->dev, "probed\n");
-
         return ret;
 
 error_probe:
@@ -1197,9 +1195,7 @@ static int mcp251x_can_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-
-static int mcp251x_can_suspend(struct device *dev)
+static int __maybe_unused mcp251x_can_suspend(struct device *dev)
 {
         struct spi_device *spi = to_spi_device(dev);
         struct mcp251x_priv *priv = spi_get_drvdata(spi);
@@ -1229,7 +1225,7 @@ static int mcp251x_can_suspend(struct device *dev)
         return 0;
 }
 
-static int mcp251x_can_resume(struct device *dev)
+static int __maybe_unused mcp251x_can_resume(struct device *dev)
 {
         struct spi_device *spi = to_spi_device(dev);
         struct mcp251x_priv *priv = spi_get_drvdata(spi);
@@ -1249,7 +1245,6 @@ static int mcp251x_can_resume(struct device *dev)
         enable_irq(spi->irq);
         return 0;
 }
-#endif
 
 static SIMPLE_DEV_PM_OPS(mcp251x_can_pm_ops, mcp251x_can_suspend,
         mcp251x_can_resume);
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index dc5f9026b67f..3ce5e526525f 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -33,8 +33,9 @@ enum can_mode {
 struct can_priv {
         struct can_device_stats can_stats;
 
-        struct can_bittiming bittiming;
-        const struct can_bittiming_const *bittiming_const;
+        struct can_bittiming bittiming, data_bittiming;
+        const struct can_bittiming_const *bittiming_const,
+                *data_bittiming_const;
         struct can_clock clock;
 
         enum can_state state;
@@ -45,6 +46,7 @@ struct can_priv {
         struct timer_list restart_timer;
 
         int (*do_set_bittiming)(struct net_device *dev);
+        int (*do_set_data_bittiming)(struct net_device *dev);
         int (*do_set_mode)(struct net_device *dev, enum can_mode mode);
         int (*do_get_state)(const struct net_device *dev,
                             enum can_state *state);
@@ -111,6 +113,7 @@ struct can_priv *safe_candev_priv(struct net_device *dev);
 
 int open_candev(struct net_device *dev);
 void close_candev(struct net_device *dev);
+int can_change_mtu(struct net_device *dev, int new_mtu);
 
 int register_candev(struct net_device *dev);
 void unregister_candev(struct net_device *dev);
diff --git a/include/uapi/linux/can/netlink.h b/include/uapi/linux/can/netlink.h
index df944ed206a8..7e2e1863db16 100644
--- a/include/uapi/linux/can/netlink.h
+++ b/include/uapi/linux/can/netlink.h
@@ -96,6 +96,7 @@ struct can_ctrlmode {
 #define CAN_CTRLMODE_3_SAMPLES          0x04    /* Triple sampling mode */
 #define CAN_CTRLMODE_ONE_SHOT           0x08    /* One-Shot mode */
 #define CAN_CTRLMODE_BERR_REPORTING     0x10    /* Bus-error reporting */
+#define CAN_CTRLMODE_FD                 0x20    /* CAN FD mode */
 
 /*
  * CAN device statistics
@@ -122,6 +123,8 @@ enum {
         IFLA_CAN_RESTART_MS,
         IFLA_CAN_RESTART,
         IFLA_CAN_BERR_COUNTER,
+        IFLA_CAN_DATA_BITTIMING,
+        IFLA_CAN_DATA_BITTIMING_CONST,
         __IFLA_CAN_MAX
 };