dev.c revision 5247a589c24022ab34e780039cc8000c48f2035e
1/* 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 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the version 2 of the GNU General Public License 8 * as published by the Free Software Foundation 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, see <http://www.gnu.org/licenses/>. 17 */ 18 19#include <linux/module.h> 20#include <linux/kernel.h> 21#include <linux/slab.h> 22#include <linux/netdevice.h> 23#include <linux/if_arp.h> 24#include <linux/can.h> 25#include <linux/can/dev.h> 26#include <linux/can/skb.h> 27#include <linux/can/netlink.h> 28#include <linux/can/led.h> 29#include <net/rtnetlink.h> 30 31#define MOD_DESC "CAN device driver interface" 32 33MODULE_DESCRIPTION(MOD_DESC); 34MODULE_LICENSE("GPL v2"); 35MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 36 37/* CAN DLC to real data length conversion helpers */ 38 39static const u8 dlc2len[] = {0, 1, 2, 3, 4, 5, 6, 7, 40 8, 12, 16, 20, 24, 32, 48, 64}; 41 42/* get data length from can_dlc with sanitized can_dlc */ 43u8 can_dlc2len(u8 can_dlc) 44{ 45 return dlc2len[can_dlc & 0x0F]; 46} 47EXPORT_SYMBOL_GPL(can_dlc2len); 48 49static const u8 len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, /* 0 - 8 */ 50 9, 9, 9, 9, /* 9 - 12 */ 51 10, 10, 10, 10, /* 13 - 16 */ 52 11, 11, 11, 11, /* 17 - 20 */ 53 12, 12, 12, 12, /* 21 - 24 */ 54 13, 13, 13, 13, 13, 13, 13, 13, /* 25 - 32 */ 55 14, 14, 14, 14, 14, 14, 14, 14, /* 33 - 40 */ 56 14, 14, 14, 14, 14, 14, 14, 14, /* 41 - 48 */ 57 15, 15, 15, 15, 15, 15, 15, 15, /* 49 - 56 */ 58 15, 15, 15, 15, 15, 15, 15, 15}; /* 57 - 64 */ 59 60/* map the sanitized data length to an appropriate data length code */ 61u8 can_len2dlc(u8 len) 62{ 63 if (unlikely(len > 64)) 64 return 0xF; 65 66 return len2dlc[len]; 67} 68EXPORT_SYMBOL_GPL(can_len2dlc); 69 70#ifdef CONFIG_CAN_CALC_BITTIMING 71#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */ 72 73/* 74 * Bit-timing calculation derived from: 75 * 76 * Code based on LinCAN sources and H8S2638 project 77 * Copyright 2004-2006 Pavel Pisa - DCE FELK CVUT cz 78 * Copyright 2005 Stanislav Marek 79 * email: pisa@cmp.felk.cvut.cz 80 * 81 * Calculates proper bit-timing parameters for a specified bit-rate 82 * and sample-point, which can then be used to set the bit-timing 83 * registers of the CAN controller. You can find more information 84 * in the header file linux/can/netlink.h. 85 */ 86static int can_update_spt(const struct can_bittiming_const *btc, 87 int sampl_pt, int tseg, int *tseg1, int *tseg2) 88{ 89 *tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000; 90 if (*tseg2 < btc->tseg2_min) 91 *tseg2 = btc->tseg2_min; 92 if (*tseg2 > btc->tseg2_max) 93 *tseg2 = btc->tseg2_max; 94 *tseg1 = tseg - *tseg2; 95 if (*tseg1 > btc->tseg1_max) { 96 *tseg1 = btc->tseg1_max; 97 *tseg2 = tseg - *tseg1; 98 } 99 return 1000 * (tseg + 1 - *tseg2) / (tseg + 1); 100} 101 102static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt, 103 const struct can_bittiming_const *btc) 104{ 105 struct can_priv *priv = netdev_priv(dev); 106 long best_error = 1000000000, error = 0; 107 int best_tseg = 0, best_brp = 0, brp = 0; 108 int tsegall, tseg = 0, tseg1 = 0, tseg2 = 0; 109 int spt_error = 1000, spt = 0, sampl_pt; 110 long rate; 111 u64 v64; 112 113 /* Use CIA recommended sample points */ 114 if (bt->sample_point) { 115 sampl_pt = bt->sample_point; 116 } else { 117 if (bt->bitrate > 800000) 118 sampl_pt = 750; 119 else if (bt->bitrate > 500000) 120 sampl_pt = 800; 121 else 122 sampl_pt = 875; 123 } 124 125 /* tseg even = round down, odd = round up */ 126 for (tseg = (btc->tseg1_max + btc->tseg2_max) * 2 + 1; 127 tseg >= (btc->tseg1_min + btc->tseg2_min) * 2; tseg--) { 128 tsegall = 1 + tseg / 2; 129 /* Compute all possible tseg choices (tseg=tseg1+tseg2) */ 130 brp = priv->clock.freq / (tsegall * bt->bitrate) + tseg % 2; 131 /* chose brp step which is possible in system */ 132 brp = (brp / btc->brp_inc) * btc->brp_inc; 133 if ((brp < btc->brp_min) || (brp > btc->brp_max)) 134 continue; 135 rate = priv->clock.freq / (brp * tsegall); 136 error = bt->bitrate - rate; 137 /* tseg brp biterror */ 138 if (error < 0) 139 error = -error; 140 if (error > best_error) 141 continue; 142 best_error = error; 143 if (error == 0) { 144 spt = can_update_spt(btc, sampl_pt, tseg / 2, 145 &tseg1, &tseg2); 146 error = sampl_pt - spt; 147 if (error < 0) 148 error = -error; 149 if (error > spt_error) 150 continue; 151 spt_error = error; 152 } 153 best_tseg = tseg / 2; 154 best_brp = brp; 155 if (error == 0) 156 break; 157 } 158 159 if (best_error) { 160 /* Error in one-tenth of a percent */ 161 error = (best_error * 1000) / bt->bitrate; 162 if (error > CAN_CALC_MAX_ERROR) { 163 netdev_err(dev, 164 "bitrate error %ld.%ld%% too high\n", 165 error / 10, error % 10); 166 return -EDOM; 167 } else { 168 netdev_warn(dev, "bitrate error %ld.%ld%%\n", 169 error / 10, error % 10); 170 } 171 } 172 173 /* real sample point */ 174 bt->sample_point = can_update_spt(btc, sampl_pt, best_tseg, 175 &tseg1, &tseg2); 176 177 v64 = (u64)best_brp * 1000000000UL; 178 do_div(v64, priv->clock.freq); 179 bt->tq = (u32)v64; 180 bt->prop_seg = tseg1 / 2; 181 bt->phase_seg1 = tseg1 - bt->prop_seg; 182 bt->phase_seg2 = tseg2; 183 184 /* check for sjw user settings */ 185 if (!bt->sjw || !btc->sjw_max) 186 bt->sjw = 1; 187 else { 188 /* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */ 189 if (bt->sjw > btc->sjw_max) 190 bt->sjw = btc->sjw_max; 191 /* bt->sjw must not be higher than tseg2 */ 192 if (tseg2 < bt->sjw) 193 bt->sjw = tseg2; 194 } 195 196 bt->brp = best_brp; 197 /* real bit-rate */ 198 bt->bitrate = priv->clock.freq / (bt->brp * (tseg1 + tseg2 + 1)); 199 200 return 0; 201} 202#else /* !CONFIG_CAN_CALC_BITTIMING */ 203static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt, 204 const struct can_bittiming_const *btc) 205{ 206 netdev_err(dev, "bit-timing calculation not available\n"); 207 return -EINVAL; 208} 209#endif /* CONFIG_CAN_CALC_BITTIMING */ 210 211/* 212 * Checks the validity of the specified bit-timing parameters prop_seg, 213 * phase_seg1, phase_seg2 and sjw and tries to determine the bitrate 214 * prescaler value brp. You can find more information in the header 215 * file linux/can/netlink.h. 216 */ 217static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt, 218 const struct can_bittiming_const *btc) 219{ 220 struct can_priv *priv = netdev_priv(dev); 221 int tseg1, alltseg; 222 u64 brp64; 223 224 tseg1 = bt->prop_seg + bt->phase_seg1; 225 if (!bt->sjw) 226 bt->sjw = 1; 227 if (bt->sjw > btc->sjw_max || 228 tseg1 < btc->tseg1_min || tseg1 > btc->tseg1_max || 229 bt->phase_seg2 < btc->tseg2_min || bt->phase_seg2 > btc->tseg2_max) 230 return -ERANGE; 231 232 brp64 = (u64)priv->clock.freq * (u64)bt->tq; 233 if (btc->brp_inc > 1) 234 do_div(brp64, btc->brp_inc); 235 brp64 += 500000000UL - 1; 236 do_div(brp64, 1000000000UL); /* the practicable BRP */ 237 if (btc->brp_inc > 1) 238 brp64 *= btc->brp_inc; 239 bt->brp = (u32)brp64; 240 241 if (bt->brp < btc->brp_min || bt->brp > btc->brp_max) 242 return -EINVAL; 243 244 alltseg = bt->prop_seg + bt->phase_seg1 + bt->phase_seg2 + 1; 245 bt->bitrate = priv->clock.freq / (bt->brp * alltseg); 246 bt->sample_point = ((tseg1 + 1) * 1000) / alltseg; 247 248 return 0; 249} 250 251static int can_get_bittiming(struct net_device *dev, struct can_bittiming *bt, 252 const struct can_bittiming_const *btc) 253{ 254 int err; 255 256 /* Check if the CAN device has bit-timing parameters */ 257 if (!btc) 258 return -EOPNOTSUPP; 259 260 /* 261 * Depending on the given can_bittiming parameter structure the CAN 262 * timing parameters are calculated based on the provided bitrate OR 263 * alternatively the CAN timing parameters (tq, prop_seg, etc.) are 264 * provided directly which are then checked and fixed up. 265 */ 266 if (!bt->tq && bt->bitrate) 267 err = can_calc_bittiming(dev, bt, btc); 268 else if (bt->tq && !bt->bitrate) 269 err = can_fixup_bittiming(dev, bt, btc); 270 else 271 err = -EINVAL; 272 273 return err; 274} 275 276/* 277 * Local echo of CAN messages 278 * 279 * CAN network devices *should* support a local echo functionality 280 * (see Documentation/networking/can.txt). To test the handling of CAN 281 * interfaces that do not support the local echo both driver types are 282 * implemented. In the case that the driver does not support the echo 283 * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core 284 * to perform the echo as a fallback solution. 285 */ 286static void can_flush_echo_skb(struct net_device *dev) 287{ 288 struct can_priv *priv = netdev_priv(dev); 289 struct net_device_stats *stats = &dev->stats; 290 int i; 291 292 for (i = 0; i < priv->echo_skb_max; i++) { 293 if (priv->echo_skb[i]) { 294 kfree_skb(priv->echo_skb[i]); 295 priv->echo_skb[i] = NULL; 296 stats->tx_dropped++; 297 stats->tx_aborted_errors++; 298 } 299 } 300} 301 302/* 303 * Put the skb on the stack to be looped backed locally lateron 304 * 305 * The function is typically called in the start_xmit function 306 * of the device driver. The driver must protect access to 307 * priv->echo_skb, if necessary. 308 */ 309void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev, 310 unsigned int idx) 311{ 312 struct can_priv *priv = netdev_priv(dev); 313 314 BUG_ON(idx >= priv->echo_skb_max); 315 316 /* check flag whether this packet has to be looped back */ 317 if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK || 318 (skb->protocol != htons(ETH_P_CAN) && 319 skb->protocol != htons(ETH_P_CANFD))) { 320 kfree_skb(skb); 321 return; 322 } 323 324 if (!priv->echo_skb[idx]) { 325 326 skb = can_create_echo_skb(skb); 327 if (!skb) 328 return; 329 330 /* make settings for echo to reduce code in irq context */ 331 skb->pkt_type = PACKET_BROADCAST; 332 skb->ip_summed = CHECKSUM_UNNECESSARY; 333 skb->dev = dev; 334 335 /* save this skb for tx interrupt echo handling */ 336 priv->echo_skb[idx] = skb; 337 } else { 338 /* locking problem with netif_stop_queue() ?? */ 339 netdev_err(dev, "%s: BUG! echo_skb is occupied!\n", __func__); 340 kfree_skb(skb); 341 } 342} 343EXPORT_SYMBOL_GPL(can_put_echo_skb); 344 345/* 346 * Get the skb from the stack and loop it back locally 347 * 348 * The function is typically called when the TX done interrupt 349 * is handled in the device driver. The driver must protect 350 * access to priv->echo_skb, if necessary. 351 */ 352unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx) 353{ 354 struct can_priv *priv = netdev_priv(dev); 355 356 BUG_ON(idx >= priv->echo_skb_max); 357 358 if (priv->echo_skb[idx]) { 359 struct sk_buff *skb = priv->echo_skb[idx]; 360 struct can_frame *cf = (struct can_frame *)skb->data; 361 u8 dlc = cf->can_dlc; 362 363 netif_rx(priv->echo_skb[idx]); 364 priv->echo_skb[idx] = NULL; 365 366 return dlc; 367 } 368 369 return 0; 370} 371EXPORT_SYMBOL_GPL(can_get_echo_skb); 372 373/* 374 * Remove the skb from the stack and free it. 375 * 376 * The function is typically called when TX failed. 377 */ 378void can_free_echo_skb(struct net_device *dev, unsigned int idx) 379{ 380 struct can_priv *priv = netdev_priv(dev); 381 382 BUG_ON(idx >= priv->echo_skb_max); 383 384 if (priv->echo_skb[idx]) { 385 dev_kfree_skb_any(priv->echo_skb[idx]); 386 priv->echo_skb[idx] = NULL; 387 } 388} 389EXPORT_SYMBOL_GPL(can_free_echo_skb); 390 391/* 392 * CAN device restart for bus-off recovery 393 */ 394static void can_restart(unsigned long data) 395{ 396 struct net_device *dev = (struct net_device *)data; 397 struct can_priv *priv = netdev_priv(dev); 398 struct net_device_stats *stats = &dev->stats; 399 struct sk_buff *skb; 400 struct can_frame *cf; 401 int err; 402 403 BUG_ON(netif_carrier_ok(dev)); 404 405 /* 406 * No synchronization needed because the device is bus-off and 407 * no messages can come in or go out. 408 */ 409 can_flush_echo_skb(dev); 410 411 /* send restart message upstream */ 412 skb = alloc_can_err_skb(dev, &cf); 413 if (skb == NULL) { 414 err = -ENOMEM; 415 goto restart; 416 } 417 cf->can_id |= CAN_ERR_RESTARTED; 418 419 netif_rx(skb); 420 421 stats->rx_packets++; 422 stats->rx_bytes += cf->can_dlc; 423 424restart: 425 netdev_dbg(dev, "restarted\n"); 426 priv->can_stats.restarts++; 427 428 /* Now restart the device */ 429 err = priv->do_set_mode(dev, CAN_MODE_START); 430 431 netif_carrier_on(dev); 432 if (err) 433 netdev_err(dev, "Error %d during restart", err); 434} 435 436int can_restart_now(struct net_device *dev) 437{ 438 struct can_priv *priv = netdev_priv(dev); 439 440 /* 441 * A manual restart is only permitted if automatic restart is 442 * disabled and the device is in the bus-off state 443 */ 444 if (priv->restart_ms) 445 return -EINVAL; 446 if (priv->state != CAN_STATE_BUS_OFF) 447 return -EBUSY; 448 449 /* Runs as soon as possible in the timer context */ 450 mod_timer(&priv->restart_timer, jiffies); 451 452 return 0; 453} 454 455/* 456 * CAN bus-off 457 * 458 * This functions should be called when the device goes bus-off to 459 * tell the netif layer that no more packets can be sent or received. 460 * If enabled, a timer is started to trigger bus-off recovery. 461 */ 462void can_bus_off(struct net_device *dev) 463{ 464 struct can_priv *priv = netdev_priv(dev); 465 466 netdev_dbg(dev, "bus-off\n"); 467 468 netif_carrier_off(dev); 469 priv->can_stats.bus_off++; 470 471 if (priv->restart_ms) 472 mod_timer(&priv->restart_timer, 473 jiffies + (priv->restart_ms * HZ) / 1000); 474} 475EXPORT_SYMBOL_GPL(can_bus_off); 476 477static void can_setup(struct net_device *dev) 478{ 479 dev->type = ARPHRD_CAN; 480 dev->mtu = CAN_MTU; 481 dev->hard_header_len = 0; 482 dev->addr_len = 0; 483 dev->tx_queue_len = 10; 484 485 /* New-style flags. */ 486 dev->flags = IFF_NOARP; 487 dev->features = NETIF_F_HW_CSUM; 488} 489 490struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf) 491{ 492 struct sk_buff *skb; 493 494 skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) + 495 sizeof(struct can_frame)); 496 if (unlikely(!skb)) 497 return NULL; 498 499 skb->protocol = htons(ETH_P_CAN); 500 skb->pkt_type = PACKET_BROADCAST; 501 skb->ip_summed = CHECKSUM_UNNECESSARY; 502 503 can_skb_reserve(skb); 504 can_skb_prv(skb)->ifindex = dev->ifindex; 505 506 *cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame)); 507 memset(*cf, 0, sizeof(struct can_frame)); 508 509 return skb; 510} 511EXPORT_SYMBOL_GPL(alloc_can_skb); 512 513struct sk_buff *alloc_canfd_skb(struct net_device *dev, 514 struct canfd_frame **cfd) 515{ 516 struct sk_buff *skb; 517 518 skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) + 519 sizeof(struct canfd_frame)); 520 if (unlikely(!skb)) 521 return NULL; 522 523 skb->protocol = htons(ETH_P_CANFD); 524 skb->pkt_type = PACKET_BROADCAST; 525 skb->ip_summed = CHECKSUM_UNNECESSARY; 526 527 can_skb_reserve(skb); 528 can_skb_prv(skb)->ifindex = dev->ifindex; 529 530 *cfd = (struct canfd_frame *)skb_put(skb, sizeof(struct canfd_frame)); 531 memset(*cfd, 0, sizeof(struct canfd_frame)); 532 533 return skb; 534} 535EXPORT_SYMBOL_GPL(alloc_canfd_skb); 536 537struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf) 538{ 539 struct sk_buff *skb; 540 541 skb = alloc_can_skb(dev, cf); 542 if (unlikely(!skb)) 543 return NULL; 544 545 (*cf)->can_id = CAN_ERR_FLAG; 546 (*cf)->can_dlc = CAN_ERR_DLC; 547 548 return skb; 549} 550EXPORT_SYMBOL_GPL(alloc_can_err_skb); 551 552/* 553 * Allocate and setup space for the CAN network device 554 */ 555struct net_device *alloc_candev(int sizeof_priv, unsigned int echo_skb_max) 556{ 557 struct net_device *dev; 558 struct can_priv *priv; 559 int size; 560 561 if (echo_skb_max) 562 size = ALIGN(sizeof_priv, sizeof(struct sk_buff *)) + 563 echo_skb_max * sizeof(struct sk_buff *); 564 else 565 size = sizeof_priv; 566 567 dev = alloc_netdev(size, "can%d", NET_NAME_UNKNOWN, can_setup); 568 if (!dev) 569 return NULL; 570 571 priv = netdev_priv(dev); 572 573 if (echo_skb_max) { 574 priv->echo_skb_max = echo_skb_max; 575 priv->echo_skb = (void *)priv + 576 ALIGN(sizeof_priv, sizeof(struct sk_buff *)); 577 } 578 579 priv->state = CAN_STATE_STOPPED; 580 581 init_timer(&priv->restart_timer); 582 583 return dev; 584} 585EXPORT_SYMBOL_GPL(alloc_candev); 586 587/* 588 * Free space of the CAN network device 589 */ 590void free_candev(struct net_device *dev) 591{ 592 free_netdev(dev); 593} 594EXPORT_SYMBOL_GPL(free_candev); 595 596/* 597 * changing MTU and control mode for CAN/CANFD devices 598 */ 599int can_change_mtu(struct net_device *dev, int new_mtu) 600{ 601 struct can_priv *priv = netdev_priv(dev); 602 603 /* Do not allow changing the MTU while running */ 604 if (dev->flags & IFF_UP) 605 return -EBUSY; 606 607 /* allow change of MTU according to the CANFD ability of the device */ 608 switch (new_mtu) { 609 case CAN_MTU: 610 priv->ctrlmode &= ~CAN_CTRLMODE_FD; 611 break; 612 613 case CANFD_MTU: 614 if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD)) 615 return -EINVAL; 616 617 priv->ctrlmode |= CAN_CTRLMODE_FD; 618 break; 619 620 default: 621 return -EINVAL; 622 } 623 624 dev->mtu = new_mtu; 625 return 0; 626} 627EXPORT_SYMBOL_GPL(can_change_mtu); 628 629/* 630 * Common open function when the device gets opened. 631 * 632 * This function should be called in the open function of the device 633 * driver. 634 */ 635int open_candev(struct net_device *dev) 636{ 637 struct can_priv *priv = netdev_priv(dev); 638 639 if (!priv->bittiming.bitrate) { 640 netdev_err(dev, "bit-timing not yet defined\n"); 641 return -EINVAL; 642 } 643 644 /* For CAN FD the data bitrate has to be >= the arbitration bitrate */ 645 if ((priv->ctrlmode & CAN_CTRLMODE_FD) && 646 (!priv->data_bittiming.bitrate || 647 (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) { 648 netdev_err(dev, "incorrect/missing data bit-timing\n"); 649 return -EINVAL; 650 } 651 652 /* Switch carrier on if device was stopped while in bus-off state */ 653 if (!netif_carrier_ok(dev)) 654 netif_carrier_on(dev); 655 656 setup_timer(&priv->restart_timer, can_restart, (unsigned long)dev); 657 658 return 0; 659} 660EXPORT_SYMBOL_GPL(open_candev); 661 662/* 663 * Common close function for cleanup before the device gets closed. 664 * 665 * This function should be called in the close function of the device 666 * driver. 667 */ 668void close_candev(struct net_device *dev) 669{ 670 struct can_priv *priv = netdev_priv(dev); 671 672 del_timer_sync(&priv->restart_timer); 673 can_flush_echo_skb(dev); 674} 675EXPORT_SYMBOL_GPL(close_candev); 676 677/* 678 * CAN netlink interface 679 */ 680static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = { 681 [IFLA_CAN_STATE] = { .type = NLA_U32 }, 682 [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) }, 683 [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 }, 684 [IFLA_CAN_RESTART] = { .type = NLA_U32 }, 685 [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) }, 686 [IFLA_CAN_BITTIMING_CONST] 687 = { .len = sizeof(struct can_bittiming_const) }, 688 [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) }, 689 [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) }, 690 [IFLA_CAN_DATA_BITTIMING] 691 = { .len = sizeof(struct can_bittiming) }, 692 [IFLA_CAN_DATA_BITTIMING_CONST] 693 = { .len = sizeof(struct can_bittiming_const) }, 694}; 695 696static int can_changelink(struct net_device *dev, 697 struct nlattr *tb[], struct nlattr *data[]) 698{ 699 struct can_priv *priv = netdev_priv(dev); 700 int err; 701 702 /* We need synchronization with dev->stop() */ 703 ASSERT_RTNL(); 704 705 if (data[IFLA_CAN_BITTIMING]) { 706 struct can_bittiming bt; 707 708 /* Do not allow changing bittiming while running */ 709 if (dev->flags & IFF_UP) 710 return -EBUSY; 711 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt)); 712 err = can_get_bittiming(dev, &bt, priv->bittiming_const); 713 if (err) 714 return err; 715 memcpy(&priv->bittiming, &bt, sizeof(bt)); 716 717 if (priv->do_set_bittiming) { 718 /* Finally, set the bit-timing registers */ 719 err = priv->do_set_bittiming(dev); 720 if (err) 721 return err; 722 } 723 } 724 725 if (data[IFLA_CAN_CTRLMODE]) { 726 struct can_ctrlmode *cm; 727 728 /* Do not allow changing controller mode while running */ 729 if (dev->flags & IFF_UP) 730 return -EBUSY; 731 cm = nla_data(data[IFLA_CAN_CTRLMODE]); 732 if (cm->flags & ~priv->ctrlmode_supported) 733 return -EOPNOTSUPP; 734 priv->ctrlmode &= ~cm->mask; 735 priv->ctrlmode |= cm->flags; 736 737 /* CAN_CTRLMODE_FD can only be set when driver supports FD */ 738 if (priv->ctrlmode & CAN_CTRLMODE_FD) 739 dev->mtu = CANFD_MTU; 740 else 741 dev->mtu = CAN_MTU; 742 } 743 744 if (data[IFLA_CAN_RESTART_MS]) { 745 /* Do not allow changing restart delay while running */ 746 if (dev->flags & IFF_UP) 747 return -EBUSY; 748 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]); 749 } 750 751 if (data[IFLA_CAN_RESTART]) { 752 /* Do not allow a restart while not running */ 753 if (!(dev->flags & IFF_UP)) 754 return -EINVAL; 755 err = can_restart_now(dev); 756 if (err) 757 return err; 758 } 759 760 if (data[IFLA_CAN_DATA_BITTIMING]) { 761 struct can_bittiming dbt; 762 763 /* Do not allow changing bittiming while running */ 764 if (dev->flags & IFF_UP) 765 return -EBUSY; 766 memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), 767 sizeof(dbt)); 768 err = can_get_bittiming(dev, &dbt, priv->data_bittiming_const); 769 if (err) 770 return err; 771 memcpy(&priv->data_bittiming, &dbt, sizeof(dbt)); 772 773 if (priv->do_set_data_bittiming) { 774 /* Finally, set the bit-timing registers */ 775 err = priv->do_set_data_bittiming(dev); 776 if (err) 777 return err; 778 } 779 } 780 781 return 0; 782} 783 784static size_t can_get_size(const struct net_device *dev) 785{ 786 struct can_priv *priv = netdev_priv(dev); 787 size_t size = 0; 788 789 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */ 790 size += nla_total_size(sizeof(struct can_bittiming)); 791 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */ 792 size += nla_total_size(sizeof(struct can_bittiming_const)); 793 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */ 794 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */ 795 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */ 796 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */ 797 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */ 798 size += nla_total_size(sizeof(struct can_berr_counter)); 799 if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 800 size += nla_total_size(sizeof(struct can_bittiming)); 801 if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 802 size += nla_total_size(sizeof(struct can_bittiming_const)); 803 804 return size; 805} 806 807static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) 808{ 809 struct can_priv *priv = netdev_priv(dev); 810 struct can_ctrlmode cm = {.flags = priv->ctrlmode}; 811 struct can_berr_counter bec; 812 enum can_state state = priv->state; 813 814 if (priv->do_get_state) 815 priv->do_get_state(dev, &state); 816 817 if ((priv->bittiming.bitrate && 818 nla_put(skb, IFLA_CAN_BITTIMING, 819 sizeof(priv->bittiming), &priv->bittiming)) || 820 821 (priv->bittiming_const && 822 nla_put(skb, IFLA_CAN_BITTIMING_CONST, 823 sizeof(*priv->bittiming_const), priv->bittiming_const)) || 824 825 nla_put(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock) || 826 nla_put_u32(skb, IFLA_CAN_STATE, state) || 827 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) || 828 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) || 829 830 (priv->do_get_berr_counter && 831 !priv->do_get_berr_counter(dev, &bec) && 832 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 833 834 (priv->data_bittiming.bitrate && 835 nla_put(skb, IFLA_CAN_DATA_BITTIMING, 836 sizeof(priv->data_bittiming), &priv->data_bittiming)) || 837 838 (priv->data_bittiming_const && 839 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST, 840 sizeof(*priv->data_bittiming_const), 841 priv->data_bittiming_const))) 842 return -EMSGSIZE; 843 844 return 0; 845} 846 847static size_t can_get_xstats_size(const struct net_device *dev) 848{ 849 return sizeof(struct can_device_stats); 850} 851 852static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev) 853{ 854 struct can_priv *priv = netdev_priv(dev); 855 856 if (nla_put(skb, IFLA_INFO_XSTATS, 857 sizeof(priv->can_stats), &priv->can_stats)) 858 goto nla_put_failure; 859 return 0; 860 861nla_put_failure: 862 return -EMSGSIZE; 863} 864 865static int can_newlink(struct net *src_net, struct net_device *dev, 866 struct nlattr *tb[], struct nlattr *data[]) 867{ 868 return -EOPNOTSUPP; 869} 870 871static struct rtnl_link_ops can_link_ops __read_mostly = { 872 .kind = "can", 873 .maxtype = IFLA_CAN_MAX, 874 .policy = can_policy, 875 .setup = can_setup, 876 .newlink = can_newlink, 877 .changelink = can_changelink, 878 .get_size = can_get_size, 879 .fill_info = can_fill_info, 880 .get_xstats_size = can_get_xstats_size, 881 .fill_xstats = can_fill_xstats, 882}; 883 884/* 885 * Register the CAN network device 886 */ 887int register_candev(struct net_device *dev) 888{ 889 dev->rtnl_link_ops = &can_link_ops; 890 return register_netdev(dev); 891} 892EXPORT_SYMBOL_GPL(register_candev); 893 894/* 895 * Unregister the CAN network device 896 */ 897void unregister_candev(struct net_device *dev) 898{ 899 unregister_netdev(dev); 900} 901EXPORT_SYMBOL_GPL(unregister_candev); 902 903/* 904 * Test if a network device is a candev based device 905 * and return the can_priv* if so. 906 */ 907struct can_priv *safe_candev_priv(struct net_device *dev) 908{ 909 if ((dev->type != ARPHRD_CAN) || (dev->rtnl_link_ops != &can_link_ops)) 910 return NULL; 911 912 return netdev_priv(dev); 913} 914EXPORT_SYMBOL_GPL(safe_candev_priv); 915 916static __init int can_dev_init(void) 917{ 918 int err; 919 920 can_led_notifier_init(); 921 922 err = rtnl_link_register(&can_link_ops); 923 if (!err) 924 printk(KERN_INFO MOD_DESC "\n"); 925 926 return err; 927} 928module_init(can_dev_init); 929 930static __exit void can_dev_exit(void) 931{ 932 rtnl_link_unregister(&can_link_ops); 933 934 can_led_notifier_exit(); 935} 936module_exit(can_dev_exit); 937 938MODULE_ALIAS_RTNL_LINK("can"); 939