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         /* real sample point */
 156         bt->sample_point = can_update_spt(btc, sampl_pt, best_tseg,
 157                                           &tseg1, &tseg2);
 158
 159         v64 = (u64)best_brp * 1000000000UL;
 160         do_div(v64, priv->clock.freq);
 161         bt->tq = (u32)v64;
 162         bt->prop_seg = tseg1 / 2;
 163         bt->phase_seg1 = tseg1 - bt->prop_seg;
 164         bt->phase_seg2 = tseg2;
 165         bt->sjw = 1;
 166         bt->brp = best_brp;
 167 #ifndef CONFIG_CAN_DEV_SYSFS
 168         /* real bit-rate */
 169         bt->bitrate = priv->clock.freq / (bt->brp * (tseg1 + tseg2 + 1));
 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 < CAN_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, int idx)
 293 {
 294         struct can_priv *priv = netdev_priv(dev);
 295
 296         /* check flag whether this packet has to be looped back */
 297         if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK) {
 298                 kfree_skb(skb);
 299                 return;
 300         }
 301
 302         if (!priv->echo_skb[idx]) {
 303                 struct sock *srcsk = skb->sk;
 304
 305                 if (atomic_read(&skb->users) != 1) {
 306                         struct sk_buff *old_skb = skb;
 307
 308                         skb = skb_clone(old_skb, GFP_ATOMIC);
 309                         kfree_skb(old_skb);
 310                         if (!skb)
 311                                 return;
 312                 } else
 313                         skb_orphan(skb);
 314
 315                 skb->sk = srcsk;
 316
 317                 /* make settings for echo to reduce code in irq context */
 318                 skb->protocol = htons(ETH_P_CAN);
 319                 skb->pkt_type = PACKET_BROADCAST;
 320                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 321                 skb->dev = dev;
 322
 323                 /* save this skb for tx interrupt echo handling */
 324                 priv->echo_skb[idx] = skb;
 325         } else {
 326                 /* locking problem with netif_stop_queue() ?? */
 327                 dev_err(ND2D(dev), "%s: BUG! echo_skb is occupied!\n",
 328                         __func__);
 329                 kfree_skb(skb);
 330         }
 331 }
 332 EXPORT_SYMBOL_GPL(can_put_echo_skb);
 333
 334 /*
 335  * Get the skb from the stack and loop it back locally
 336  *
 337  * The function is typically called when the TX done interrupt
 338  * is handled in the device driver. The driver must protect
 339  * access to priv->echo_skb, if necessary.
 340  */
 341 void can_get_echo_skb(struct net_device *dev, int idx)
 342 {
 343         struct can_priv *priv = netdev_priv(dev);
 344
 345         if (priv->echo_skb[idx]) {
 346                 netif_rx(priv->echo_skb[idx]);
 347                 priv->echo_skb[idx] = NULL;
 348         }
 349 }
 350 EXPORT_SYMBOL_GPL(can_get_echo_skb);
 351
 352 /*
 353   * Remove the skb from the stack and free it.
 354   *
 355   * The function is typically called when TX failed.
 356   */
 357 void can_free_echo_skb(struct net_device *dev, int idx)
 358 {
 359         struct can_priv *priv = netdev_priv(dev);
 360
 361         if (priv->echo_skb[idx]) {
 362                 kfree_skb(priv->echo_skb[idx]);
 363                 priv->echo_skb[idx] = NULL;
 364         }
 365 }
 366 EXPORT_SYMBOL_GPL(can_free_echo_skb);
 367
 368 /*
 369  * CAN device restart for bus-off recovery
 370  */
 371 void can_restart(unsigned long data)
 372 {
 373         struct net_device *dev = (struct net_device *)data;
 374         struct can_priv *priv = netdev_priv(dev);
 375 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 376         struct net_device_stats *stats = can_get_stats(dev);
 377 #else
 378         struct net_device_stats *stats = &dev->stats;
 379 #endif
 380         struct sk_buff *skb;
 381         struct can_frame *cf;
 382         int err;
 383
 384         BUG_ON(netif_carrier_ok(dev));
 385
 386         /*
 387          * No synchronization needed because the device is bus-off and
 388          * no messages can come in or go out.
 389          */
 390         can_flush_echo_skb(dev);
 391
 392         /* send restart message upstream */
 393         skb = dev_alloc_skb(sizeof(struct can_frame));
 394         if (skb == NULL) {
 395                 err = -ENOMEM;
 396                 goto restart;
 397         }
 398         skb->dev = dev;
 399         skb->protocol = htons(ETH_P_CAN);
 400         cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
 401         memset(cf, 0, sizeof(struct can_frame));
 402         cf->can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
 403         cf->can_dlc = CAN_ERR_DLC;
 404
 405         netif_rx(skb);
 406
 407         dev->last_rx = jiffies;
 408         stats->rx_packets++;
 409         stats->rx_bytes += cf->can_dlc;
 410
 411 restart:
 412         dev_dbg(ND2D(dev), "restarted\n");
 413         priv->can_stats.restarts++;
 414
 415         /* Now restart the device */
 416         err = priv->do_set_mode(dev, CAN_MODE_START);
 417
 418         netif_carrier_on(dev);
 419         if (err)
 420                 dev_err(ND2D(dev), "Error %d during restart", err);
 421 }
 422
 423 int can_restart_now(struct net_device *dev)
 424 {
 425         struct can_priv *priv = netdev_priv(dev);
 426
 427         /*
 428          * A manual restart is only permitted if automatic restart is
 429          * disabled and the device is in the bus-off state
 430          */
 431         if (priv->restart_ms)
 432                 return -EINVAL;
 433         if (priv->state != CAN_STATE_BUS_OFF)
 434                 return -EBUSY;
 435
 436         /* Runs as soon as possible in the timer context */
 437         mod_timer(&priv->restart_timer, jiffies);
 438
 439         return 0;
 440 }
 441
 442 /*
 443  * CAN bus-off
 444  *
 445  * This functions should be called when the device goes bus-off to
 446  * tell the netif layer that no more packets can be sent or received.
 447  * If enabled, a timer is started to trigger bus-off recovery.
 448  */
 449 void can_bus_off(struct net_device *dev)
 450 {
 451         struct can_priv *priv = netdev_priv(dev);
 452
 453         dev_dbg(ND2D(dev), "bus-off\n");
 454
 455         netif_carrier_off(dev);
 456         priv->can_stats.bus_off++;
 457
 458         if (priv->restart_ms)
 459                 mod_timer(&priv->restart_timer,
 460                           jiffies + (priv->restart_ms * HZ) / 1000);
 461 }
 462 EXPORT_SYMBOL_GPL(can_bus_off);
 463
 464 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 465 struct net_device_stats *can_get_stats(struct net_device *dev)
 466 {
 467         struct can_priv *priv = netdev_priv(dev);
 468
 469         return &priv->net_stats;
 470 }
 471 EXPORT_SYMBOL_GPL(can_get_stats);
 472 #endif
 473
 474 static void can_setup(struct net_device *dev)
 475 {
 476         dev->type = ARPHRD_CAN;
 477         dev->mtu = sizeof(struct can_frame);
 478         dev->hard_header_len = 0;
 479         dev->addr_len = 0;
 480         dev->tx_queue_len = 10;
 481
 482         /* New-style flags. */
 483         dev->flags = IFF_NOARP;
 484         dev->features = NETIF_F_NO_CSUM;
 485 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 486         dev->get_stats = can_get_stats;
 487 #endif
 488 }
 489
 490 /*
 491  * Allocate and setup space for the CAN network device
 492  */
 493 struct net_device *alloc_candev(int sizeof_priv)
 494 {
 495         struct net_device *dev;
 496         struct can_priv *priv;
 497
 498         dev = alloc_netdev(sizeof_priv, "can%d", can_setup);
 499         if (!dev)
 500                 return NULL;
 501
 502         priv = netdev_priv(dev);
 503
 504         priv->state = CAN_STATE_STOPPED;
 505
 506         init_timer(&priv->restart_timer);
 507
 508         return dev;
 509 }
 510 EXPORT_SYMBOL_GPL(alloc_candev);
 511
 512 /*
 513  * Free space of the CAN network device
 514  */
 515 void free_candev(struct net_device *dev)
 516 {
 517         free_netdev(dev);
 518 }
 519 EXPORT_SYMBOL_GPL(free_candev);
 520
 521 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
 522 static inline void setup_timer(struct timer_list * timer,
 523                                 void (*function)(unsigned long),
 524                                 unsigned long data)
 525 {
 526         timer->function = function;
 527         timer->data = data;
 528         init_timer(timer);
 529 }
 530 #endif
 531
 532 /*
 533  * Common open function when the device gets opened.
 534  *
 535  * This function should be called in the open function of the device
 536  * driver.
 537  */
 538 int open_candev(struct net_device *dev)
 539 {
 540         struct can_priv *priv = netdev_priv(dev);
 541 #ifdef CONFIG_CAN_DEV_SYSFS
 542         int err;
 543 #endif
 544
 545         if (!priv->bittiming.tq && !priv->bittiming.bitrate) {
 546                 dev_err(ND2D(dev), "bit-timing not yet defined\n");
 547                 return -EINVAL;
 548         }
 549
 550 #ifdef CONFIG_CAN_DEV_SYSFS
 551         err = can_get_bittiming(dev, &priv->bittiming);
 552         if (err)
 553                 return err;
 554
 555         if (priv->do_set_bittiming) {
 556                 /* Finally, set the bit-timing registers */
 557                 err = priv->do_set_bittiming(dev);
 558                 if (err)
 559                         return err;
 560         }
 561 #endif
 562
 563         /* Switch carrier on if device was stopped while in bus-off state */
 564         if (!netif_carrier_ok(dev))
 565                 netif_carrier_on(dev);
 566
 567         setup_timer(&priv->restart_timer, can_restart, (unsigned long)dev);
 568
 569         return 0;
 570 }
 571 EXPORT_SYMBOL_GPL(open_candev);
 572
 573 /*
 574  * Common close function for cleanup before the device gets closed.
 575  *
 576  * This function should be called in the close function of the device
 577  * driver.
 578  */
 579 void close_candev(struct net_device *dev)
 580 {
 581         struct can_priv *priv = netdev_priv(dev);
 582
 583         if (del_timer_sync(&priv->restart_timer))
 584                 dev_put(dev);
 585         can_flush_echo_skb(dev);
 586 }
 587 EXPORT_SYMBOL_GPL(close_candev);
 588
 589 #ifndef CONFIG_CAN_DEV_SYSFS
 590 /*
 591  * CAN netlink interface
 592  */
 593 static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
 594         [IFLA_CAN_STATE]        = { .type = NLA_U32 },
 595         [IFLA_CAN_CTRLMODE]     = { .len = sizeof(struct can_ctrlmode) },
 596         [IFLA_CAN_RESTART_MS]   = { .type = NLA_U32 },
 597         [IFLA_CAN_RESTART]      = { .type = NLA_U32 },
 598         [IFLA_CAN_BITTIMING]    = { .len = sizeof(struct can_bittiming) },
 599         [IFLA_CAN_BITTIMING_CONST]
 600                                 = { .len = sizeof(struct can_bittiming_const) },
 601         [IFLA_CAN_CLOCK]        = { .len = sizeof(struct can_clock) },
 602 };
 603
 604 static int can_changelink(struct net_device *dev,
 605                           struct nlattr *tb[], struct nlattr *data[])
 606 {
 607         struct can_priv *priv = netdev_priv(dev);
 608         int err;
 609
 610         /* We need synchronization with dev->stop() */
 611         ASSERT_RTNL();
 612
 613         if (data[IFLA_CAN_CTRLMODE]) {
 614                 struct can_ctrlmode *cm;
 615
 616                 /* Do not allow changing controller mode while running */
 617                 if (dev->flags & IFF_UP)
 618                         return -EBUSY;
 619                 cm = nla_data(data[IFLA_CAN_CTRLMODE]);
 620                 priv->ctrlmode &= ~cm->mask;
 621                 priv->ctrlmode |= cm->flags;
 622         }
 623
 624         if (data[IFLA_CAN_BITTIMING]) {
 625                 struct can_bittiming bt;
 626
 627                 /* Do not allow changing bittiming while running */
 628                 if (dev->flags & IFF_UP)
 629                         return -EBUSY;
 630                 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
 631                 if ((!bt.bitrate && !bt.tq) || (bt.bitrate && bt.tq))
 632                         return -EINVAL;
 633                 err = can_get_bittiming(dev, &bt);
 634                 if (err)
 635                         return err;
 636                 memcpy(&priv->bittiming, &bt, sizeof(bt));
 637
 638                 if (priv->do_set_bittiming) {
 639                         /* Finally, set the bit-timing registers */
 640                         err = priv->do_set_bittiming(dev);
 641                         if (err)
 642                                 return err;
 643                 }
 644         }
 645
 646         if (data[IFLA_CAN_RESTART_MS]) {
 647                 /* Do not allow changing restart delay while running */
 648                 if (dev->flags & IFF_UP)
 649                         return -EBUSY;
 650                 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
 651         }
 652
 653         if (data[IFLA_CAN_RESTART]) {
 654                 /* Do not allow a restart while not running */
 655                 if (!(dev->flags & IFF_UP))
 656                         return -EINVAL;
 657                 err = can_restart_now(dev);
 658                 if (err)
 659                         return err;
 660         }
 661
 662         return 0;
 663 }
 664
 665 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
 666 {
 667         struct can_priv *priv = netdev_priv(dev);
 668         struct can_ctrlmode cm = {.flags = priv->ctrlmode};
 669         enum can_state state = priv->state;
 670
 671         if (priv->do_get_state)
 672                 priv->do_get_state(dev, &state);
 673         NLA_PUT_U32(skb, IFLA_CAN_STATE, state);
 674         NLA_PUT(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm);
 675         NLA_PUT_U32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms);
 676         NLA_PUT(skb, IFLA_CAN_BITTIMING,
 677                 sizeof(priv->bittiming), &priv->bittiming);
 678         NLA_PUT(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock);
 679         if (priv->bittiming_const)
 680                 NLA_PUT(skb, IFLA_CAN_BITTIMING_CONST,
 681                         sizeof(*priv->bittiming_const), priv->bittiming_const);
 682
 683         return 0;
 684
 685 nla_put_failure:
 686         return -EMSGSIZE;
 687 }
 688
 689 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
 690 {
 691         struct can_priv *priv = netdev_priv(dev);
 692
 693         NLA_PUT(skb, IFLA_INFO_XSTATS,
 694                 sizeof(priv->can_stats), &priv->can_stats);
 695
 696         return 0;
 697
 698 nla_put_failure:
 699         return -EMSGSIZE;
 700 }
 701
 702 static int can_newlink(struct net_device *dev,
 703                        struct nlattr *tb[], struct nlattr *data[])
 704 {
 705         return -EOPNOTSUPP;
 706 }
 707
 708 static struct rtnl_link_ops can_link_ops __read_mostly = {
 709         .kind           = "can",
 710         .maxtype        = IFLA_CAN_MAX,
 711         .policy         = can_policy,
 712         .setup          = can_setup,
 713         .newlink        = can_newlink,
 714         .changelink     = can_changelink,
 715         .fill_info      = can_fill_info,
 716         .fill_xstats    = can_fill_xstats,
 717 };
 718
 719 #endif /* !CONFIG_CAN_DEV_SYSFS */
 720
 721 /*
 722  * Register the CAN network device
 723  */
 724 int register_candev(struct net_device *dev)
 725 {
 726 #ifdef CONFIG_CAN_DEV_SYSFS
 727         int err;
 728
 729         err = register_netdev(dev);
 730         if (!err)
 731                 can_create_sysfs(dev);
 732
 733         return err;
 734 #else
 735         dev->rtnl_link_ops = &can_link_ops;
 736         return register_netdev(dev);
 737 #endif
 738 }
 739 EXPORT_SYMBOL_GPL(register_candev);
 740
 741 /*
 742  * Unregister the CAN network device
 743  */
 744 void unregister_candev(struct net_device *dev)
 745 {
 746 #ifdef CONFIG_CAN_DEV_SYSFS
 747         can_remove_sysfs(dev);
 748 #endif
 749         unregister_netdev(dev);
 750 }
 751 EXPORT_SYMBOL_GPL(unregister_candev);
 752
 753 static __init int can_dev_init(void)
 754 {
 755 #ifndef CONFIG_CAN_DEV_SYSFS
 756         int err;
 757
 758         err = rtnl_link_register(&can_link_ops);
 759         if (!err)
 760                 printk(KERN_INFO MOD_DESC "\n");
 761
 762         return err;
 763 #else
 764         printk(KERN_INFO MOD_DESC " using the deprecated SYSFS interface\n");
 765
 766         return 0;
 767 #endif
 768 }
 769 module_init(can_dev_init);
 770
 771 static __exit void can_dev_exit(void)
 772 {
 773 #ifndef CONFIG_CAN_DEV_SYSFS
 774         rtnl_link_unregister(&can_link_ops);
 775 #endif
 776 }
 777 module_exit(can_dev_exit);
 778
 779 #ifndef CONFIG_CAN_DEV_SYSFS
 780 MODULE_ALIAS_RTNL_LINK("can");
 781 #endif