drivers/net/can/dev/dev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
   3  * Copyright (C) 2006 Andrey Volkov, Varma Electronics
   4  * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/slab.h>
   9 #include <linux/netdevice.h>
  10 #include <linux/if_arp.h>
  11 #include <linux/workqueue.h>
  12 #include <linux/can.h>
  13 #include <linux/can/can-ml.h>
  14 #include <linux/can/dev.h>
  15 #include <linux/can/skb.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/of.h>
  18
  19 static void can_update_state_error_stats(struct net_device *dev,
  20                                          enum can_state new_state)
  21 {
  22         struct can_priv *priv = netdev_priv(dev);
  23
  24         if (new_state <= priv->state)
  25                 return;
  26
  27         switch (new_state) {
  28         case CAN_STATE_ERROR_WARNING:
  29                 priv->can_stats.error_warning++;
  30                 break;
  31         case CAN_STATE_ERROR_PASSIVE:
  32                 priv->can_stats.error_passive++;
  33                 break;
  34         case CAN_STATE_BUS_OFF:
  35                 priv->can_stats.bus_off++;
  36                 break;
  37         default:
  38                 break;
  39         }
  40 }
  41
  42 static int can_tx_state_to_frame(struct net_device *dev, enum can_state state)
  43 {
  44         switch (state) {
  45         case CAN_STATE_ERROR_ACTIVE:
  46                 return CAN_ERR_CRTL_ACTIVE;
  47         case CAN_STATE_ERROR_WARNING:
  48                 return CAN_ERR_CRTL_TX_WARNING;
  49         case CAN_STATE_ERROR_PASSIVE:
  50                 return CAN_ERR_CRTL_TX_PASSIVE;
  51         default:
  52                 return 0;
  53         }
  54 }
  55
  56 static int can_rx_state_to_frame(struct net_device *dev, enum can_state state)
  57 {
  58         switch (state) {
  59         case CAN_STATE_ERROR_ACTIVE:
  60                 return CAN_ERR_CRTL_ACTIVE;
  61         case CAN_STATE_ERROR_WARNING:
  62                 return CAN_ERR_CRTL_RX_WARNING;
  63         case CAN_STATE_ERROR_PASSIVE:
  64                 return CAN_ERR_CRTL_RX_PASSIVE;
  65         default:
  66                 return 0;
  67         }
  68 }
  69
  70 const char *can_get_state_str(const enum can_state state)
  71 {
  72         switch (state) {
  73         case CAN_STATE_ERROR_ACTIVE:
  74                 return "Error Active";
  75         case CAN_STATE_ERROR_WARNING:
  76                 return "Error Warning";
  77         case CAN_STATE_ERROR_PASSIVE:
  78                 return "Error Passive";
  79         case CAN_STATE_BUS_OFF:
  80                 return "Bus Off";
  81         case CAN_STATE_STOPPED:
  82                 return "Stopped";
  83         case CAN_STATE_SLEEPING:
  84                 return "Sleeping";
  85         default:
  86                 return "<unknown>";
  87         }
  88
  89         return "<unknown>";
  90 }
  91 EXPORT_SYMBOL_GPL(can_get_state_str);
  92
  93 static enum can_state can_state_err_to_state(u16 err)
  94 {
  95         if (err < CAN_ERROR_WARNING_THRESHOLD)
  96                 return CAN_STATE_ERROR_ACTIVE;
  97         if (err < CAN_ERROR_PASSIVE_THRESHOLD)
  98                 return CAN_STATE_ERROR_WARNING;
  99         if (err < CAN_BUS_OFF_THRESHOLD)
 100                 return CAN_STATE_ERROR_PASSIVE;
 101
 102         return CAN_STATE_BUS_OFF;
 103 }
 104
 105 void can_state_get_by_berr_counter(const struct net_device *dev,
 106                                    const struct can_berr_counter *bec,
 107                                    enum can_state *tx_state,
 108                                    enum can_state *rx_state)
 109 {
 110         *tx_state = can_state_err_to_state(bec->txerr);
 111         *rx_state = can_state_err_to_state(bec->rxerr);
 112 }
 113 EXPORT_SYMBOL_GPL(can_state_get_by_berr_counter);
 114
 115 void can_change_state(struct net_device *dev, struct can_frame *cf,
 116                       enum can_state tx_state, enum can_state rx_state)
 117 {
 118         struct can_priv *priv = netdev_priv(dev);
 119         enum can_state new_state = max(tx_state, rx_state);
 120
 121         if (unlikely(new_state == priv->state)) {
 122                 netdev_warn(dev, "%s: oops, state did not change", __func__);
 123                 return;
 124         }
 125
 126         netdev_dbg(dev, "Controller changed from %s State (%d) into %s State (%d).\n",
 127                    can_get_state_str(priv->state), priv->state,
 128                    can_get_state_str(new_state), new_state);
 129
 130         can_update_state_error_stats(dev, new_state);
 131         priv->state = new_state;
 132
 133         if (!cf)
 134                 return;
 135
 136         if (unlikely(new_state == CAN_STATE_BUS_OFF)) {
 137                 cf->can_id |= CAN_ERR_BUSOFF;
 138                 return;
 139         }
 140
 141         cf->can_id |= CAN_ERR_CRTL;
 142         cf->data[1] |= tx_state >= rx_state ?
 143                        can_tx_state_to_frame(dev, tx_state) : 0;
 144         cf->data[1] |= tx_state <= rx_state ?
 145                        can_rx_state_to_frame(dev, rx_state) : 0;
 146 }
 147 EXPORT_SYMBOL_GPL(can_change_state);
 148
 149 /* CAN device restart for bus-off recovery */
 150 static void can_restart(struct net_device *dev)
 151 {
 152         struct can_priv *priv = netdev_priv(dev);
 153         struct sk_buff *skb;
 154         struct can_frame *cf;
 155         int err;
 156
 157         if (netif_carrier_ok(dev))
 158                 netdev_err(dev, "Attempt to restart for bus-off recovery, but carrier is OK?\n");
 159
 160         /* No synchronization needed because the device is bus-off and
 161          * no messages can come in or go out.
 162          */
 163         can_flush_echo_skb(dev);
 164
 165         /* send restart message upstream */
 166         skb = alloc_can_err_skb(dev, &cf);
 167         if (skb) {
 168                 cf->can_id |= CAN_ERR_RESTARTED;
 169                 netif_rx(skb);
 170         }
 171
 172         /* Now restart the device */
 173         netif_carrier_on(dev);
 174         err = priv->do_set_mode(dev, CAN_MODE_START);
 175         if (err) {
 176                 netdev_err(dev, "Restart failed, error %pe\n", ERR_PTR(err));
 177                 netif_carrier_off(dev);
 178         } else {
 179                 netdev_dbg(dev, "Restarted\n");
 180                 priv->can_stats.restarts++;
 181         }
 182 }
 183
 184 static void can_restart_work(struct work_struct *work)
 185 {
 186         struct delayed_work *dwork = to_delayed_work(work);
 187         struct can_priv *priv = container_of(dwork, struct can_priv,
 188                                              restart_work);
 189
 190         can_restart(priv->dev);
 191 }
 192
 193 int can_restart_now(struct net_device *dev)
 194 {
 195         struct can_priv *priv = netdev_priv(dev);
 196
 197         /* A manual restart is only permitted if automatic restart is
 198          * disabled and the device is in the bus-off state
 199          */
 200         if (priv->restart_ms)
 201                 return -EINVAL;
 202         if (priv->state != CAN_STATE_BUS_OFF)
 203                 return -EBUSY;
 204
 205         cancel_delayed_work_sync(&priv->restart_work);
 206         can_restart(dev);
 207
 208         return 0;
 209 }
 210
 211 /* CAN bus-off
 212  *
 213  * This functions should be called when the device goes bus-off to
 214  * tell the netif layer that no more packets can be sent or received.
 215  * If enabled, a timer is started to trigger bus-off recovery.
 216  */
 217 void can_bus_off(struct net_device *dev)
 218 {
 219         struct can_priv *priv = netdev_priv(dev);
 220
 221         if (priv->restart_ms)
 222                 netdev_info(dev, "bus-off, scheduling restart in %d ms\n",
 223                             priv->restart_ms);
 224         else
 225                 netdev_info(dev, "bus-off\n");
 226
 227         netif_carrier_off(dev);
 228
 229         if (priv->restart_ms)
 230                 schedule_delayed_work(&priv->restart_work,
 231                                       msecs_to_jiffies(priv->restart_ms));
 232 }
 233 EXPORT_SYMBOL_GPL(can_bus_off);
 234
 235 void can_setup(struct net_device *dev)
 236 {
 237         dev->type = ARPHRD_CAN;
 238         dev->mtu = CAN_MTU;
 239         dev->hard_header_len = 0;
 240         dev->addr_len = 0;
 241         dev->tx_queue_len = 10;
 242
 243         /* New-style flags. */
 244         dev->flags = IFF_NOARP;
 245         dev->features = NETIF_F_HW_CSUM;
 246 }
 247
 248 /* Allocate and setup space for the CAN network device */
 249 struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
 250                                     unsigned int txqs, unsigned int rxqs)
 251 {
 252         struct can_ml_priv *can_ml;
 253         struct net_device *dev;
 254         struct can_priv *priv;
 255         int size;
 256
 257         /* We put the driver's priv, the CAN mid layer priv and the
 258          * echo skb into the netdevice's priv. The memory layout for
 259          * the netdev_priv is like this:
 260          *
 261          * +-------------------------+
 262          * | driver's priv           |
 263          * +-------------------------+
 264          * | struct can_ml_priv      |
 265          * +-------------------------+
 266          * | array of struct sk_buff |
 267          * +-------------------------+
 268          */
 269
 270         size = ALIGN(sizeof_priv, NETDEV_ALIGN) + sizeof(struct can_ml_priv);
 271
 272         if (echo_skb_max)
 273                 size = ALIGN(size, sizeof(struct sk_buff *)) +
 274                         echo_skb_max * sizeof(struct sk_buff *);
 275
 276         dev = alloc_netdev_mqs(size, "can%d", NET_NAME_UNKNOWN, can_setup,
 277                                txqs, rxqs);
 278         if (!dev)
 279                 return NULL;
 280
 281         priv = netdev_priv(dev);
 282         priv->dev = dev;
 283
 284         can_ml = (void *)priv + ALIGN(sizeof_priv, NETDEV_ALIGN);
 285         can_set_ml_priv(dev, can_ml);
 286
 287         if (echo_skb_max) {
 288                 priv->echo_skb_max = echo_skb_max;
 289                 priv->echo_skb = (void *)priv +
 290                         (size - echo_skb_max * sizeof(struct sk_buff *));
 291         }
 292
 293         priv->state = CAN_STATE_STOPPED;
 294
 295         INIT_DELAYED_WORK(&priv->restart_work, can_restart_work);
 296
 297         return dev;
 298 }
 299 EXPORT_SYMBOL_GPL(alloc_candev_mqs);
 300
 301 /* Free space of the CAN network device */
 302 void free_candev(struct net_device *dev)
 303 {
 304         free_netdev(dev);
 305 }
 306 EXPORT_SYMBOL_GPL(free_candev);
 307
 308 /* changing MTU and control mode for CAN/CANFD devices */
 309 int can_change_mtu(struct net_device *dev, int new_mtu)
 310 {
 311         struct can_priv *priv = netdev_priv(dev);
 312         u32 ctrlmode_static = can_get_static_ctrlmode(priv);
 313
 314         /* Do not allow changing the MTU while running */
 315         if (dev->flags & IFF_UP)
 316                 return -EBUSY;
 317
 318         /* allow change of MTU according to the CANFD ability of the device */
 319         switch (new_mtu) {
 320         case CAN_MTU:
 321                 /* 'CANFD-only' controllers can not switch to CAN_MTU */
 322                 if (ctrlmode_static & CAN_CTRLMODE_FD)
 323                         return -EINVAL;
 324
 325                 priv->ctrlmode &= ~CAN_CTRLMODE_FD;
 326                 break;
 327
 328         case CANFD_MTU:
 329                 /* check for potential CANFD ability */
 330                 if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD) &&
 331                     !(ctrlmode_static & CAN_CTRLMODE_FD))
 332                         return -EINVAL;
 333
 334                 priv->ctrlmode |= CAN_CTRLMODE_FD;
 335                 break;
 336
 337         default:
 338                 return -EINVAL;
 339         }
 340
 341         WRITE_ONCE(dev->mtu, new_mtu);
 342         return 0;
 343 }
 344 EXPORT_SYMBOL_GPL(can_change_mtu);
 345
 346 /* generic implementation of netdev_ops::ndo_eth_ioctl for CAN devices
 347  * supporting hardware timestamps
 348  */
 349 int can_eth_ioctl_hwts(struct net_device *netdev, struct ifreq *ifr, int cmd)
 350 {
 351         struct hwtstamp_config hwts_cfg = { 0 };
 352
 353         switch (cmd) {
 354         case SIOCSHWTSTAMP: /* set */
 355                 if (copy_from_user(&hwts_cfg, ifr->ifr_data, sizeof(hwts_cfg)))
 356                         return -EFAULT;
 357                 if (hwts_cfg.tx_type == HWTSTAMP_TX_ON &&
 358                     hwts_cfg.rx_filter == HWTSTAMP_FILTER_ALL)
 359                         return 0;
 360                 return -ERANGE;
 361
 362         case SIOCGHWTSTAMP: /* get */
 363                 hwts_cfg.tx_type = HWTSTAMP_TX_ON;
 364                 hwts_cfg.rx_filter = HWTSTAMP_FILTER_ALL;
 365                 if (copy_to_user(ifr->ifr_data, &hwts_cfg, sizeof(hwts_cfg)))
 366                         return -EFAULT;
 367                 return 0;
 368
 369         default:
 370                 return -EOPNOTSUPP;
 371         }
 372 }
 373 EXPORT_SYMBOL(can_eth_ioctl_hwts);
 374
 375 /* generic implementation of ethtool_ops::get_ts_info for CAN devices
 376  * supporting hardware timestamps
 377  */
 378 int can_ethtool_op_get_ts_info_hwts(struct net_device *dev,
 379                                     struct kernel_ethtool_ts_info *info)
 380 {
 381         info->so_timestamping =
 382                 SOF_TIMESTAMPING_TX_SOFTWARE |
 383                 SOF_TIMESTAMPING_TX_HARDWARE |
 384                 SOF_TIMESTAMPING_RX_HARDWARE |
 385                 SOF_TIMESTAMPING_RAW_HARDWARE;
 386         info->tx_types = BIT(HWTSTAMP_TX_ON);
 387         info->rx_filters = BIT(HWTSTAMP_FILTER_ALL);
 388
 389         return 0;
 390 }
 391 EXPORT_SYMBOL(can_ethtool_op_get_ts_info_hwts);
 392
 393 /* Common open function when the device gets opened.
 394  *
 395  * This function should be called in the open function of the device
 396  * driver.
 397  */
 398 int open_candev(struct net_device *dev)
 399 {
 400         struct can_priv *priv = netdev_priv(dev);
 401
 402         if (!priv->bittiming.bitrate) {
 403                 netdev_err(dev, "bit-timing not yet defined\n");
 404                 return -EINVAL;
 405         }
 406
 407         /* For CAN FD the data bitrate has to be >= the arbitration bitrate */
 408         if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&
 409             (!priv->data_bittiming.bitrate ||
 410              priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {
 411                 netdev_err(dev, "incorrect/missing data bit-timing\n");
 412                 return -EINVAL;
 413         }
 414
 415         /* Switch carrier on if device was stopped while in bus-off state */
 416         if (!netif_carrier_ok(dev))
 417                 netif_carrier_on(dev);
 418
 419         return 0;
 420 }
 421 EXPORT_SYMBOL_GPL(open_candev);
 422
 423 #ifdef CONFIG_OF
 424 /* Common function that can be used to understand the limitation of
 425  * a transceiver when it provides no means to determine these limitations
 426  * at runtime.
 427  */
 428 void of_can_transceiver(struct net_device *dev)
 429 {
 430         struct device_node *dn;
 431         struct can_priv *priv = netdev_priv(dev);
 432         struct device_node *np = dev->dev.parent->of_node;
 433         int ret;
 434
 435         dn = of_get_child_by_name(np, "can-transceiver");
 436         if (!dn)
 437                 return;
 438
 439         ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
 440         of_node_put(dn);
 441         if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
 442                 netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
 443 }
 444 EXPORT_SYMBOL_GPL(of_can_transceiver);
 445 #endif
 446
 447 /* Common close function for cleanup before the device gets closed.
 448  *
 449  * This function should be called in the close function of the device
 450  * driver.
 451  */
 452 void close_candev(struct net_device *dev)
 453 {
 454         struct can_priv *priv = netdev_priv(dev);
 455
 456         cancel_delayed_work_sync(&priv->restart_work);
 457         can_flush_echo_skb(dev);
 458 }
 459 EXPORT_SYMBOL_GPL(close_candev);
 460
 461 static int can_set_termination(struct net_device *ndev, u16 term)
 462 {
 463         struct can_priv *priv = netdev_priv(ndev);
 464         int set;
 465
 466         if (term == priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_ENABLED])
 467                 set = 1;
 468         else
 469                 set = 0;
 470
 471         gpiod_set_value(priv->termination_gpio, set);
 472
 473         return 0;
 474 }
 475
 476 static int can_get_termination(struct net_device *ndev)
 477 {
 478         struct can_priv *priv = netdev_priv(ndev);
 479         struct device *dev = ndev->dev.parent;
 480         struct gpio_desc *gpio;
 481         u32 term;
 482         int ret;
 483
 484         /* Disabling termination by default is the safe choice: Else if many
 485          * bus participants enable it, no communication is possible at all.
 486          */
 487         gpio = devm_gpiod_get_optional(dev, "termination", GPIOD_OUT_LOW);
 488         if (IS_ERR(gpio))
 489                 return dev_err_probe(dev, PTR_ERR(gpio),
 490                                      "Cannot get termination-gpios\n");
 491
 492         if (!gpio)
 493                 return 0;
 494
 495         ret = device_property_read_u32(dev, "termination-ohms", &term);
 496         if (ret) {
 497                 netdev_err(ndev, "Cannot get termination-ohms: %pe\n",
 498                            ERR_PTR(ret));
 499                 return ret;
 500         }
 501
 502         if (term > U16_MAX) {
 503                 netdev_err(ndev, "Invalid termination-ohms value (%u > %u)\n",
 504                            term, U16_MAX);
 505                 return -EINVAL;
 506         }
 507
 508         priv->termination_const_cnt = ARRAY_SIZE(priv->termination_gpio_ohms);
 509         priv->termination_const = priv->termination_gpio_ohms;
 510         priv->termination_gpio = gpio;
 511         priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_DISABLED] =
 512                 CAN_TERMINATION_DISABLED;
 513         priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_ENABLED] = term;
 514         priv->do_set_termination = can_set_termination;
 515
 516         return 0;
 517 }
 518
 519 static bool
 520 can_bittiming_const_valid(const struct can_bittiming_const *btc)
 521 {
 522         if (!btc)
 523                 return true;
 524
 525         if (!btc->sjw_max)
 526                 return false;
 527
 528         return true;
 529 }
 530
 531 /* Register the CAN network device */
 532 int register_candev(struct net_device *dev)
 533 {
 534         struct can_priv *priv = netdev_priv(dev);
 535         int err;
 536
 537         /* Ensure termination_const, termination_const_cnt and
 538          * do_set_termination consistency. All must be either set or
 539          * unset.
 540          */
 541         if ((!priv->termination_const != !priv->termination_const_cnt) ||
 542             (!priv->termination_const != !priv->do_set_termination))
 543                 return -EINVAL;
 544
 545         if (!priv->bitrate_const != !priv->bitrate_const_cnt)
 546                 return -EINVAL;
 547
 548         if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt)
 549                 return -EINVAL;
 550
 551         /* We only support either fixed bit rates or bit timing const. */
 552         if ((priv->bitrate_const || priv->data_bitrate_const) &&
 553             (priv->bittiming_const || priv->data_bittiming_const))
 554                 return -EINVAL;
 555
 556         if (!can_bittiming_const_valid(priv->bittiming_const) ||
 557             !can_bittiming_const_valid(priv->data_bittiming_const))
 558                 return -EINVAL;
 559
 560         if (!priv->termination_const) {
 561                 err = can_get_termination(dev);
 562                 if (err)
 563                         return err;
 564         }
 565
 566         dev->rtnl_link_ops = &can_link_ops;
 567         netif_carrier_off(dev);
 568
 569         return register_netdev(dev);
 570 }
 571 EXPORT_SYMBOL_GPL(register_candev);
 572
 573 /* Unregister the CAN network device */
 574 void unregister_candev(struct net_device *dev)
 575 {
 576         unregister_netdev(dev);
 577 }
 578 EXPORT_SYMBOL_GPL(unregister_candev);
 579
 580 /* Test if a network device is a candev based device
 581  * and return the can_priv* if so.
 582  */
 583 struct can_priv *safe_candev_priv(struct net_device *dev)
 584 {
 585         if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops)
 586                 return NULL;
 587
 588         return netdev_priv(dev);
 589 }
 590 EXPORT_SYMBOL_GPL(safe_candev_priv);
 591
 592 static __init int can_dev_init(void)
 593 {
 594         int err;
 595
 596         err = can_netlink_register();
 597         if (!err)
 598                 pr_info("CAN device driver interface\n");
 599
 600         return err;
 601 }
 602 module_init(can_dev_init);
 603
 604 static __exit void can_dev_exit(void)
 605 {
 606         can_netlink_unregister();
 607 }
 608 module_exit(can_dev_exit);
 609
 610 MODULE_ALIAS_RTNL_LINK("can");