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