kernel/2.6/drivers/net/can/dev.c

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