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 19static 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 42static 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 56static 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 70const 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} 91EXPORT_SYMBOL_GPL(can_get_state_str); 92 93static 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 105void 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} 113EXPORT_SYMBOL_GPL(can_state_get_by_berr_counter); 114 115void 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} 147EXPORT_SYMBOL_GPL(can_change_state); 148 149/* CAN device restart for bus-off recovery */ 150static 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 184static 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 193int 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 */ 217void 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} 233EXPORT_SYMBOL_GPL(can_bus_off); 234 235void 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 */ 249struct 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} 299EXPORT_SYMBOL_GPL(alloc_candev_mqs); 300 301/* Free space of the CAN network device */ 302void free_candev(struct net_device *dev) 303{ 304 free_netdev(dev); 305} 306EXPORT_SYMBOL_GPL(free_candev); 307 308/* changing MTU and control mode for CAN/CANFD devices */ 309int 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 dev->mtu = new_mtu; 342 return 0; 343} 344EXPORT_SYMBOL_GPL(can_change_mtu); 345 346/* generic implementation of netdev_ops::ndo_eth_ioctl for CAN devices 347 * supporting hardware timestamps 348 */ 349int 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} 373EXPORT_SYMBOL(can_eth_ioctl_hwts); 374 375/* generic implementation of ethtool_ops::get_ts_info for CAN devices 376 * supporting hardware timestamps 377 */ 378int can_ethtool_op_get_ts_info_hwts(struct net_device *dev, 379 struct ethtool_ts_info *info) 380{ 381 info->so_timestamping = 382 SOF_TIMESTAMPING_TX_SOFTWARE | 383 SOF_TIMESTAMPING_RX_SOFTWARE | 384 SOF_TIMESTAMPING_SOFTWARE | 385 SOF_TIMESTAMPING_TX_HARDWARE | 386 SOF_TIMESTAMPING_RX_HARDWARE | 387 SOF_TIMESTAMPING_RAW_HARDWARE; 388 info->phc_index = -1; 389 info->tx_types = BIT(HWTSTAMP_TX_ON); 390 info->rx_filters = BIT(HWTSTAMP_FILTER_ALL); 391 392 return 0; 393} 394EXPORT_SYMBOL(can_ethtool_op_get_ts_info_hwts); 395 396/* Common open function when the device gets opened. 397 * 398 * This function should be called in the open function of the device 399 * driver. 400 */ 401int open_candev(struct net_device *dev) 402{ 403 struct can_priv *priv = netdev_priv(dev); 404 405 if (!priv->bittiming.bitrate) { 406 netdev_err(dev, "bit-timing not yet defined\n"); 407 return -EINVAL; 408 } 409 410 /* For CAN FD the data bitrate has to be >= the arbitration bitrate */ 411 if ((priv->ctrlmode & CAN_CTRLMODE_FD) && 412 (!priv->data_bittiming.bitrate || 413 priv->data_bittiming.bitrate < priv->bittiming.bitrate)) { 414 netdev_err(dev, "incorrect/missing data bit-timing\n"); 415 return -EINVAL; 416 } 417 418 /* Switch carrier on if device was stopped while in bus-off state */ 419 if (!netif_carrier_ok(dev)) 420 netif_carrier_on(dev); 421 422 return 0; 423} 424EXPORT_SYMBOL_GPL(open_candev); 425 426#ifdef CONFIG_OF 427/* Common function that can be used to understand the limitation of 428 * a transceiver when it provides no means to determine these limitations 429 * at runtime. 430 */ 431void of_can_transceiver(struct net_device *dev) 432{ 433 struct device_node *dn; 434 struct can_priv *priv = netdev_priv(dev); 435 struct device_node *np = dev->dev.parent->of_node; 436 int ret; 437 438 dn = of_get_child_by_name(np, "can-transceiver"); 439 if (!dn) 440 return; 441 442 ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max); 443 of_node_put(dn); 444 if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max)) 445 netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n"); 446} 447EXPORT_SYMBOL_GPL(of_can_transceiver); 448#endif 449 450/* Common close function for cleanup before the device gets closed. 451 * 452 * This function should be called in the close function of the device 453 * driver. 454 */ 455void close_candev(struct net_device *dev) 456{ 457 struct can_priv *priv = netdev_priv(dev); 458 459 cancel_delayed_work_sync(&priv->restart_work); 460 can_flush_echo_skb(dev); 461} 462EXPORT_SYMBOL_GPL(close_candev); 463 464static int can_set_termination(struct net_device *ndev, u16 term) 465{ 466 struct can_priv *priv = netdev_priv(ndev); 467 int set; 468 469 if (term == priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_ENABLED]) 470 set = 1; 471 else 472 set = 0; 473 474 gpiod_set_value(priv->termination_gpio, set); 475 476 return 0; 477} 478 479static int can_get_termination(struct net_device *ndev) 480{ 481 struct can_priv *priv = netdev_priv(ndev); 482 struct device *dev = ndev->dev.parent; 483 struct gpio_desc *gpio; 484 u32 term; 485 int ret; 486 487 /* Disabling termination by default is the safe choice: Else if many 488 * bus participants enable it, no communication is possible at all. 489 */ 490 gpio = devm_gpiod_get_optional(dev, "termination", GPIOD_OUT_LOW); 491 if (IS_ERR(gpio)) 492 return dev_err_probe(dev, PTR_ERR(gpio), 493 "Cannot get termination-gpios\n"); 494 495 if (!gpio) 496 return 0; 497 498 ret = device_property_read_u32(dev, "termination-ohms", &term); 499 if (ret) { 500 netdev_err(ndev, "Cannot get termination-ohms: %pe\n", 501 ERR_PTR(ret)); 502 return ret; 503 } 504 505 if (term > U16_MAX) { 506 netdev_err(ndev, "Invalid termination-ohms value (%u > %u)\n", 507 term, U16_MAX); 508 return -EINVAL; 509 } 510 511 priv->termination_const_cnt = ARRAY_SIZE(priv->termination_gpio_ohms); 512 priv->termination_const = priv->termination_gpio_ohms; 513 priv->termination_gpio = gpio; 514 priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_DISABLED] = 515 CAN_TERMINATION_DISABLED; 516 priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_ENABLED] = term; 517 priv->do_set_termination = can_set_termination; 518 519 return 0; 520} 521 522static bool 523can_bittiming_const_valid(const struct can_bittiming_const *btc) 524{ 525 if (!btc) 526 return true; 527 528 if (!btc->sjw_max) 529 return false; 530 531 return true; 532} 533 534/* Register the CAN network device */ 535int register_candev(struct net_device *dev) 536{ 537 struct can_priv *priv = netdev_priv(dev); 538 int err; 539 540 /* Ensure termination_const, termination_const_cnt and 541 * do_set_termination consistency. All must be either set or 542 * unset. 543 */ 544 if ((!priv->termination_const != !priv->termination_const_cnt) || 545 (!priv->termination_const != !priv->do_set_termination)) 546 return -EINVAL; 547 548 if (!priv->bitrate_const != !priv->bitrate_const_cnt) 549 return -EINVAL; 550 551 if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt) 552 return -EINVAL; 553 554 /* We only support either fixed bit rates or bit timing const. */ 555 if ((priv->bitrate_const || priv->data_bitrate_const) && 556 (priv->bittiming_const || priv->data_bittiming_const)) 557 return -EINVAL; 558 559 if (!can_bittiming_const_valid(priv->bittiming_const) || 560 !can_bittiming_const_valid(priv->data_bittiming_const)) 561 return -EINVAL; 562 563 if (!priv->termination_const) { 564 err = can_get_termination(dev); 565 if (err) 566 return err; 567 } 568 569 dev->rtnl_link_ops = &can_link_ops; 570 netif_carrier_off(dev); 571 572 return register_netdev(dev); 573} 574EXPORT_SYMBOL_GPL(register_candev); 575 576/* Unregister the CAN network device */ 577void unregister_candev(struct net_device *dev) 578{ 579 unregister_netdev(dev); 580} 581EXPORT_SYMBOL_GPL(unregister_candev); 582 583/* Test if a network device is a candev based device 584 * and return the can_priv* if so. 585 */ 586struct can_priv *safe_candev_priv(struct net_device *dev) 587{ 588 if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops) 589 return NULL; 590 591 return netdev_priv(dev); 592} 593EXPORT_SYMBOL_GPL(safe_candev_priv); 594 595static __init int can_dev_init(void) 596{ 597 int err; 598 599 err = can_netlink_register(); 600 if (!err) 601 pr_info("CAN device driver interface\n"); 602 603 return err; 604} 605module_init(can_dev_init); 606 607static __exit void can_dev_exit(void) 608{ 609 can_netlink_unregister(); 610} 611module_exit(can_dev_exit); 612 613MODULE_ALIAS_RTNL_LINK("can"); 614