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 <[email protected]>
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/kernel.h>
   9 #include <linux/slab.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/if_arp.h>
  12 #include <linux/workqueue.h>
  13 #include <linux/can.h>
  14 #include <linux/can/can-ml.h>
  15 #include <linux/can/dev.h>
  16 #include <linux/can/skb.h>
  17 #include <linux/can/led.h>
  18 #include <linux/of.h>
  19
  20 #define MOD_DESC "CAN device driver interface"
  21
  22 MODULE_DESCRIPTION(MOD_DESC);
  23 MODULE_LICENSE("GPL v2");
  24 MODULE_AUTHOR("Wolfgang Grandegger <[email protected]>");
  25
  26 static void can_update_state_error_stats(struct net_device *dev,
  27                                          enum can_state new_state)
  28 {
  29         struct can_priv *priv = netdev_priv(dev);
  30
  31         if (new_state <= priv->state)
  32                 return;
  33
  34         switch (new_state) {
  35         case CAN_STATE_ERROR_WARNING:
  36                 priv->can_stats.error_warning++;
  37                 break;
  38         case CAN_STATE_ERROR_PASSIVE:
  39                 priv->can_stats.error_passive++;
  40                 break;
  41         case CAN_STATE_BUS_OFF:
  42                 priv->can_stats.bus_off++;
  43                 break;
  44         default:
  45                 break;
  46         }
  47 }
  48
  49 static int can_tx_state_to_frame(struct net_device *dev, enum can_state state)
  50 {
  51         switch (state) {
  52         case CAN_STATE_ERROR_ACTIVE:
  53                 return CAN_ERR_CRTL_ACTIVE;
  54         case CAN_STATE_ERROR_WARNING:
  55                 return CAN_ERR_CRTL_TX_WARNING;
  56         case CAN_STATE_ERROR_PASSIVE:
  57                 return CAN_ERR_CRTL_TX_PASSIVE;
  58         default:
  59                 return 0;
  60         }
  61 }
  62
  63 static int can_rx_state_to_frame(struct net_device *dev, enum can_state state)
  64 {
  65         switch (state) {
  66         case CAN_STATE_ERROR_ACTIVE:
  67                 return CAN_ERR_CRTL_ACTIVE;
  68         case CAN_STATE_ERROR_WARNING:
  69                 return CAN_ERR_CRTL_RX_WARNING;
  70         case CAN_STATE_ERROR_PASSIVE:
  71                 return CAN_ERR_CRTL_RX_PASSIVE;
  72         default:
  73                 return 0;
  74         }
  75 }
  76
  77 const char *can_get_state_str(const enum can_state state)
  78 {
  79         switch (state) {
  80         case CAN_STATE_ERROR_ACTIVE:
  81                 return "Error Active";
  82         case CAN_STATE_ERROR_WARNING:
  83                 return "Error Warning";
  84         case CAN_STATE_ERROR_PASSIVE:
  85                 return "Error Passive";
  86         case CAN_STATE_BUS_OFF:
  87                 return "Bus Off";
  88         case CAN_STATE_STOPPED:
  89                 return "Stopped";
  90         case CAN_STATE_SLEEPING:
  91                 return "Sleeping";
  92         default:
  93                 return "<unknown>";
  94         }
  95
  96         return "<unknown>";
  97 }
  98 EXPORT_SYMBOL_GPL(can_get_state_str);
  99
 100 void can_change_state(struct net_device *dev, struct can_frame *cf,
 101                       enum can_state tx_state, enum can_state rx_state)
 102 {
 103         struct can_priv *priv = netdev_priv(dev);
 104         enum can_state new_state = max(tx_state, rx_state);
 105
 106         if (unlikely(new_state == priv->state)) {
 107                 netdev_warn(dev, "%s: oops, state did not change", __func__);
 108                 return;
 109         }
 110
 111         netdev_dbg(dev, "Controller changed from %s State (%d) into %s State (%d).\n",
 112                    can_get_state_str(priv->state), priv->state,
 113                    can_get_state_str(new_state), new_state);
 114
 115         can_update_state_error_stats(dev, new_state);
 116         priv->state = new_state;
 117
 118         if (!cf)
 119                 return;
 120
 121         if (unlikely(new_state == CAN_STATE_BUS_OFF)) {
 122                 cf->can_id |= CAN_ERR_BUSOFF;
 123                 return;
 124         }
 125
 126         cf->can_id |= CAN_ERR_CRTL;
 127         cf->data[1] |= tx_state >= rx_state ?
 128                        can_tx_state_to_frame(dev, tx_state) : 0;
 129         cf->data[1] |= tx_state <= rx_state ?
 130                        can_rx_state_to_frame(dev, rx_state) : 0;
 131 }
 132 EXPORT_SYMBOL_GPL(can_change_state);
 133
 134 /* CAN device restart for bus-off recovery */
 135 static void can_restart(struct net_device *dev)
 136 {
 137         struct can_priv *priv = netdev_priv(dev);
 138         struct net_device_stats *stats = &dev->stats;
 139         struct sk_buff *skb;
 140         struct can_frame *cf;
 141         int err;
 142
 143         BUG_ON(netif_carrier_ok(dev));
 144
 145         /* No synchronization needed because the device is bus-off and
 146          * no messages can come in or go out.
 147          */
 148         can_flush_echo_skb(dev);
 149
 150         /* send restart message upstream */
 151         skb = alloc_can_err_skb(dev, &cf);
 152         if (!skb)
 153                 goto restart;
 154
 155         cf->can_id |= CAN_ERR_RESTARTED;
 156
 157         stats->rx_packets++;
 158         stats->rx_bytes += cf->len;
 159
 160         netif_rx_ni(skb);
 161
 162 restart:
 163         netdev_dbg(dev, "restarted\n");
 164         priv->can_stats.restarts++;
 165
 166         /* Now restart the device */
 167         err = priv->do_set_mode(dev, CAN_MODE_START);
 168
 169         netif_carrier_on(dev);
 170         if (err)
 171                 netdev_err(dev, "Error %d during restart", err);
 172 }
 173
 174 static void can_restart_work(struct work_struct *work)
 175 {
 176         struct delayed_work *dwork = to_delayed_work(work);
 177         struct can_priv *priv = container_of(dwork, struct can_priv,
 178                                              restart_work);
 179
 180         can_restart(priv->dev);
 181 }
 182
 183 int can_restart_now(struct net_device *dev)
 184 {
 185         struct can_priv *priv = netdev_priv(dev);
 186
 187         /* A manual restart is only permitted if automatic restart is
 188          * disabled and the device is in the bus-off state
 189          */
 190         if (priv->restart_ms)
 191                 return -EINVAL;
 192         if (priv->state != CAN_STATE_BUS_OFF)
 193                 return -EBUSY;
 194
 195         cancel_delayed_work_sync(&priv->restart_work);
 196         can_restart(dev);
 197
 198         return 0;
 199 }
 200
 201 /* CAN bus-off
 202  *
 203  * This functions should be called when the device goes bus-off to
 204  * tell the netif layer that no more packets can be sent or received.
 205  * If enabled, a timer is started to trigger bus-off recovery.
 206  */
 207 void can_bus_off(struct net_device *dev)
 208 {
 209         struct can_priv *priv = netdev_priv(dev);
 210
 211         if (priv->restart_ms)
 212                 netdev_info(dev, "bus-off, scheduling restart in %d ms\n",
 213                             priv->restart_ms);
 214         else
 215                 netdev_info(dev, "bus-off\n");
 216
 217         netif_carrier_off(dev);
 218
 219         if (priv->restart_ms)
 220                 schedule_delayed_work(&priv->restart_work,
 221                                       msecs_to_jiffies(priv->restart_ms));
 222 }
 223 EXPORT_SYMBOL_GPL(can_bus_off);
 224
 225 void can_setup(struct net_device *dev)
 226 {
 227         dev->type = ARPHRD_CAN;
 228         dev->mtu = CAN_MTU;
 229         dev->hard_header_len = 0;
 230         dev->addr_len = 0;
 231         dev->tx_queue_len = 10;
 232
 233         /* New-style flags. */
 234         dev->flags = IFF_NOARP;
 235         dev->features = NETIF_F_HW_CSUM;
 236 }
 237
 238 /* Allocate and setup space for the CAN network device */
 239 struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
 240                                     unsigned int txqs, unsigned int rxqs)
 241 {
 242         struct can_ml_priv *can_ml;
 243         struct net_device *dev;
 244         struct can_priv *priv;
 245         int size;
 246
 247         /* We put the driver's priv, the CAN mid layer priv and the
 248          * echo skb into the netdevice's priv. The memory layout for
 249          * the netdev_priv is like this:
 250          *
 251          * +-------------------------+
 252          * | driver's priv           |
 253          * +-------------------------+
 254          * | struct can_ml_priv      |
 255          * +-------------------------+
 256          * | array of struct sk_buff |
 257          * +-------------------------+
 258          */
 259
 260         size = ALIGN(sizeof_priv, NETDEV_ALIGN) + sizeof(struct can_ml_priv);
 261
 262         if (echo_skb_max)
 263                 size = ALIGN(size, sizeof(struct sk_buff *)) +
 264                         echo_skb_max * sizeof(struct sk_buff *);
 265
 266         dev = alloc_netdev_mqs(size, "can%d", NET_NAME_UNKNOWN, can_setup,
 267                                txqs, rxqs);
 268         if (!dev)
 269                 return NULL;
 270
 271         priv = netdev_priv(dev);
 272         priv->dev = dev;
 273
 274         can_ml = (void *)priv + ALIGN(sizeof_priv, NETDEV_ALIGN);
 275         can_set_ml_priv(dev, can_ml);
 276
 277         if (echo_skb_max) {
 278                 priv->echo_skb_max = echo_skb_max;
 279                 priv->echo_skb = (void *)priv +
 280                         (size - echo_skb_max * sizeof(struct sk_buff *));
 281         }
 282
 283         priv->state = CAN_STATE_STOPPED;
 284
 285         INIT_DELAYED_WORK(&priv->restart_work, can_restart_work);
 286
 287         return dev;
 288 }
 289 EXPORT_SYMBOL_GPL(alloc_candev_mqs);
 290
 291 /* Free space of the CAN network device */
 292 void free_candev(struct net_device *dev)
 293 {
 294         free_netdev(dev);
 295 }
 296 EXPORT_SYMBOL_GPL(free_candev);
 297
 298 /* changing MTU and control mode for CAN/CANFD devices */
 299 int can_change_mtu(struct net_device *dev, int new_mtu)
 300 {
 301         struct can_priv *priv = netdev_priv(dev);
 302
 303         /* Do not allow changing the MTU while running */
 304         if (dev->flags & IFF_UP)
 305                 return -EBUSY;
 306
 307         /* allow change of MTU according to the CANFD ability of the device */
 308         switch (new_mtu) {
 309         case CAN_MTU:
 310                 /* 'CANFD-only' controllers can not switch to CAN_MTU */
 311                 if (priv->ctrlmode_static & CAN_CTRLMODE_FD)
 312                         return -EINVAL;
 313
 314                 priv->ctrlmode &= ~CAN_CTRLMODE_FD;
 315                 break;
 316
 317         case CANFD_MTU:
 318                 /* check for potential CANFD ability */
 319                 if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD) &&
 320                     !(priv->ctrlmode_static & CAN_CTRLMODE_FD))
 321                         return -EINVAL;
 322
 323                 priv->ctrlmode |= CAN_CTRLMODE_FD;
 324                 break;
 325
 326         default:
 327                 return -EINVAL;
 328         }
 329
 330         dev->mtu = new_mtu;
 331         return 0;
 332 }
 333 EXPORT_SYMBOL_GPL(can_change_mtu);
 334
 335 /* Common open function when the device gets opened.
 336  *
 337  * This function should be called in the open function of the device
 338  * driver.
 339  */
 340 int open_candev(struct net_device *dev)
 341 {
 342         struct can_priv *priv = netdev_priv(dev);
 343
 344         if (!priv->bittiming.bitrate) {
 345                 netdev_err(dev, "bit-timing not yet defined\n");
 346                 return -EINVAL;
 347         }
 348
 349         /* For CAN FD the data bitrate has to be >= the arbitration bitrate */
 350         if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&
 351             (!priv->data_bittiming.bitrate ||
 352              priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {
 353                 netdev_err(dev, "incorrect/missing data bit-timing\n");
 354                 return -EINVAL;
 355         }
 356
 357         /* Switch carrier on if device was stopped while in bus-off state */
 358         if (!netif_carrier_ok(dev))
 359                 netif_carrier_on(dev);
 360
 361         return 0;
 362 }
 363 EXPORT_SYMBOL_GPL(open_candev);
 364
 365 #ifdef CONFIG_OF
 366 /* Common function that can be used to understand the limitation of
 367  * a transceiver when it provides no means to determine these limitations
 368  * at runtime.
 369  */
 370 void of_can_transceiver(struct net_device *dev)
 371 {
 372         struct device_node *dn;
 373         struct can_priv *priv = netdev_priv(dev);
 374         struct device_node *np = dev->dev.parent->of_node;
 375         int ret;
 376
 377         dn = of_get_child_by_name(np, "can-transceiver");
 378         if (!dn)
 379                 return;
 380
 381         ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
 382         of_node_put(dn);
 383         if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
 384                 netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
 385 }
 386 EXPORT_SYMBOL_GPL(of_can_transceiver);
 387 #endif
 388
 389 /* Common close function for cleanup before the device gets closed.
 390  *
 391  * This function should be called in the close function of the device
 392  * driver.
 393  */
 394 void close_candev(struct net_device *dev)
 395 {
 396         struct can_priv *priv = netdev_priv(dev);
 397
 398         cancel_delayed_work_sync(&priv->restart_work);
 399         can_flush_echo_skb(dev);
 400 }
 401 EXPORT_SYMBOL_GPL(close_candev);
 402
 403 /* Register the CAN network device */
 404 int register_candev(struct net_device *dev)
 405 {
 406         struct can_priv *priv = netdev_priv(dev);
 407
 408         /* Ensure termination_const, termination_const_cnt and
 409          * do_set_termination consistency. All must be either set or
 410          * unset.
 411          */
 412         if ((!priv->termination_const != !priv->termination_const_cnt) ||
 413             (!priv->termination_const != !priv->do_set_termination))
 414                 return -EINVAL;
 415
 416         if (!priv->bitrate_const != !priv->bitrate_const_cnt)
 417                 return -EINVAL;
 418
 419         if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt)
 420                 return -EINVAL;
 421
 422         dev->rtnl_link_ops = &can_link_ops;
 423         netif_carrier_off(dev);
 424
 425         return register_netdev(dev);
 426 }
 427 EXPORT_SYMBOL_GPL(register_candev);
 428
 429 /* Unregister the CAN network device */
 430 void unregister_candev(struct net_device *dev)
 431 {
 432         unregister_netdev(dev);
 433 }
 434 EXPORT_SYMBOL_GPL(unregister_candev);
 435
 436 /* Test if a network device is a candev based device
 437  * and return the can_priv* if so.
 438  */
 439 struct can_priv *safe_candev_priv(struct net_device *dev)
 440 {
 441         if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops)
 442                 return NULL;
 443
 444         return netdev_priv(dev);
 445 }
 446 EXPORT_SYMBOL_GPL(safe_candev_priv);
 447
 448 static __init int can_dev_init(void)
 449 {
 450         int err;
 451
 452         can_led_notifier_init();
 453
 454         err = can_netlink_register();
 455         if (!err)
 456                 pr_info(MOD_DESC "\n");
 457
 458         return err;
 459 }
 460 module_init(can_dev_init);
 461
 462 static __exit void can_dev_exit(void)
 463 {
 464         can_netlink_unregister();
 465
 466         can_led_notifier_exit();
 467 }
 468 module_exit(can_dev_exit);
 469
 470 MODULE_ALIAS_RTNL_LINK("can");