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 = __constant_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 = alloc_can_err_skb(dev, &cf);
 401         if (skb == NULL) {
 402                 err = -ENOMEM;
 403                 goto restart;
 404         }
 405         cf->can_id |= CAN_ERR_RESTARTED;
 406
 407         netif_rx(skb);
 408
 409 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 410         dev->last_rx = jiffies;
 411 #endif
 412         stats->rx_packets++;
 413         stats->rx_bytes += cf->can_dlc;
 414
 415 restart:
 416         dev_dbg(ND2D(dev), "restarted\n");
 417         priv->can_stats.restarts++;
 418
 419         /* Now restart the device */
 420         err = priv->do_set_mode(dev, CAN_MODE_START);
 421
 422         netif_carrier_on(dev);
 423         if (err)
 424                 dev_err(ND2D(dev), "Error %d during restart", err);
 425 }
 426
 427 int can_restart_now(struct net_device *dev)
 428 {
 429         struct can_priv *priv = netdev_priv(dev);
 430
 431         /*
 432          * A manual restart is only permitted if automatic restart is
 433          * disabled and the device is in the bus-off state
 434          */
 435         if (priv->restart_ms)
 436                 return -EINVAL;
 437         if (priv->state != CAN_STATE_BUS_OFF)
 438                 return -EBUSY;
 439
 440         /* Runs as soon as possible in the timer context */
 441         mod_timer(&priv->restart_timer, jiffies);
 442
 443         return 0;
 444 }
 445
 446 /*
 447  * CAN bus-off
 448  *
 449  * This functions should be called when the device goes bus-off to
 450  * tell the netif layer that no more packets can be sent or received.
 451  * If enabled, a timer is started to trigger bus-off recovery.
 452  */
 453 void can_bus_off(struct net_device *dev)
 454 {
 455         struct can_priv *priv = netdev_priv(dev);
 456
 457         dev_dbg(ND2D(dev), "bus-off\n");
 458
 459         netif_carrier_off(dev);
 460         priv->can_stats.bus_off++;
 461
 462         if (priv->restart_ms)
 463                 mod_timer(&priv->restart_timer,
 464                           jiffies + (priv->restart_ms * HZ) / 1000);
 465 }
 466 EXPORT_SYMBOL_GPL(can_bus_off);
 467
 468 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 469 struct net_device_stats *can_get_stats(struct net_device *dev)
 470 {
 471         struct can_priv *priv = netdev_priv(dev);
 472
 473         return &priv->net_stats;
 474 }
 475 EXPORT_SYMBOL_GPL(can_get_stats);
 476 #endif
 477
 478 static void can_setup(struct net_device *dev)
 479 {
 480         dev->type = ARPHRD_CAN;
 481         dev->mtu = sizeof(struct can_frame);
 482         dev->hard_header_len = 0;
 483         dev->addr_len = 0;
 484         dev->tx_queue_len = 10;
 485
 486         /* New-style flags. */
 487         dev->flags = IFF_NOARP;
 488         dev->features = NETIF_F_NO_CSUM;
 489 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 490         dev->get_stats = can_get_stats;
 491 #endif
 492 }
 493
 494 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf)
 495 {
 496         struct sk_buff *skb;
 497
 498         skb = netdev_alloc_skb(dev, sizeof(struct can_frame));
 499         if (unlikely(!skb))
 500                 return NULL;
 501
 502         skb->protocol = __constant_htons(ETH_P_CAN);
 503         skb->pkt_type = PACKET_BROADCAST;
 504         skb->ip_summed = CHECKSUM_UNNECESSARY;
 505         *cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
 506         memset(*cf, 0, sizeof(struct can_frame));
 507
 508         return skb;
 509 }
 510 EXPORT_SYMBOL_GPL(alloc_can_skb);
 511
 512 struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf)
 513 {
 514         struct sk_buff *skb;
 515
 516         skb = alloc_can_skb(dev, cf);
 517         if (unlikely(!skb))
 518                 return NULL;
 519
 520         (*cf)->can_id = CAN_ERR_FLAG;
 521         (*cf)->can_dlc = CAN_ERR_DLC;
 522
 523         return skb;
 524 }
 525 EXPORT_SYMBOL_GPL(alloc_can_err_skb);
 526
 527 /*
 528  * Allocate and setup space for the CAN network device
 529  */
 530 struct net_device *alloc_candev(int sizeof_priv, unsigned int echo_skb_max)
 531 {
 532         struct net_device *dev;
 533         struct can_priv *priv;
 534         int size;
 535
 536         if (echo_skb_max)
 537                 size = ALIGN(sizeof_priv, sizeof(struct sk_buff *)) +
 538                         echo_skb_max * sizeof(struct sk_buff *);
 539         else
 540                 size = sizeof_priv;
 541
 542         dev = alloc_netdev(size, "can%d", can_setup);
 543         if (!dev)
 544                 return NULL;
 545
 546         priv = netdev_priv(dev);
 547
 548         if (echo_skb_max) {
 549                 priv->echo_skb_max = echo_skb_max;
 550                 priv->echo_skb = (void *)priv +
 551                         ALIGN(sizeof_priv, sizeof(struct sk_buff *));
 552         }
 553
 554         priv->state = CAN_STATE_STOPPED;
 555
 556         init_timer(&priv->restart_timer);
 557
 558         return dev;
 559 }
 560 EXPORT_SYMBOL_GPL(alloc_candev);
 561
 562 /*
 563  * Free space of the CAN network device
 564  */
 565 void free_candev(struct net_device *dev)
 566 {
 567         free_netdev(dev);
 568 }
 569 EXPORT_SYMBOL_GPL(free_candev);
 570
 571 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
 572 static inline void setup_timer(struct timer_list * timer,
 573                                 void (*function)(unsigned long),
 574                                 unsigned long data)
 575 {
 576         timer->function = function;
 577         timer->data = data;
 578         init_timer(timer);
 579 }
 580 #endif
 581
 582 /*
 583  * Common open function when the device gets opened.
 584  *
 585  * This function should be called in the open function of the device
 586  * driver.
 587  */
 588 int open_candev(struct net_device *dev)
 589 {
 590         struct can_priv *priv = netdev_priv(dev);
 591 #ifdef CONFIG_CAN_DEV_SYSFS
 592         int err;
 593 #endif
 594
 595         if (!priv->bittiming.tq && !priv->bittiming.bitrate) {
 596                 dev_err(ND2D(dev), "bit-timing not yet defined\n");
 597                 return -EINVAL;
 598         }
 599
 600 #ifdef CONFIG_CAN_DEV_SYSFS
 601         err = can_get_bittiming(dev, &priv->bittiming);
 602         if (err)
 603                 return err;
 604
 605         if (priv->do_set_bittiming) {
 606                 /* Finally, set the bit-timing registers */
 607                 err = priv->do_set_bittiming(dev);
 608                 if (err)
 609                         return err;
 610         }
 611 #endif
 612
 613         /* Switch carrier on if device was stopped while in bus-off state */
 614         if (!netif_carrier_ok(dev))
 615                 netif_carrier_on(dev);
 616
 617         setup_timer(&priv->restart_timer, can_restart, (unsigned long)dev);
 618
 619         return 0;
 620 }
 621 EXPORT_SYMBOL_GPL(open_candev);
 622
 623 /*
 624  * Common close function for cleanup before the device gets closed.
 625  *
 626  * This function should be called in the close function of the device
 627  * driver.
 628  */
 629 void close_candev(struct net_device *dev)
 630 {
 631         struct can_priv *priv = netdev_priv(dev);
 632
 633         if (del_timer_sync(&priv->restart_timer))
 634                 dev_put(dev);
 635         can_flush_echo_skb(dev);
 636 }
 637 EXPORT_SYMBOL_GPL(close_candev);
 638
 639 #ifndef CONFIG_CAN_DEV_SYSFS
 640 /*
 641  * CAN netlink interface
 642  */
 643 static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
 644         [IFLA_CAN_STATE]        = { .type = NLA_U32 },
 645         [IFLA_CAN_CTRLMODE]     = { .len = sizeof(struct can_ctrlmode) },
 646         [IFLA_CAN_RESTART_MS]   = { .type = NLA_U32 },
 647         [IFLA_CAN_RESTART]      = { .type = NLA_U32 },
 648         [IFLA_CAN_BITTIMING]    = { .len = sizeof(struct can_bittiming) },
 649         [IFLA_CAN_BITTIMING_CONST]
 650                                 = { .len = sizeof(struct can_bittiming_const) },
 651         [IFLA_CAN_CLOCK]        = { .len = sizeof(struct can_clock) },
 652         [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
 653 };
 654
 655 static int can_changelink(struct net_device *dev,
 656                           struct nlattr *tb[], struct nlattr *data[])
 657 {
 658         struct can_priv *priv = netdev_priv(dev);
 659         int err;
 660
 661         /* We need synchronization with dev->stop() */
 662         ASSERT_RTNL();
 663
 664         if (data[IFLA_CAN_CTRLMODE]) {
 665                 struct can_ctrlmode *cm;
 666
 667                 /* Do not allow changing controller mode while running */
 668                 if (dev->flags & IFF_UP)
 669                         return -EBUSY;
 670                 cm = nla_data(data[IFLA_CAN_CTRLMODE]);
 671                 if (cm->flags & ~priv->ctrlmode_supported)
 672                         return -EOPNOTSUPP;
 673                 priv->ctrlmode &= ~cm->mask;
 674                 priv->ctrlmode |= cm->flags;
 675         }
 676
 677         if (data[IFLA_CAN_BITTIMING]) {
 678                 struct can_bittiming bt;
 679
 680                 /* Do not allow changing bittiming while running */
 681                 if (dev->flags & IFF_UP)
 682                         return -EBUSY;
 683                 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
 684                 if ((!bt.bitrate && !bt.tq) || (bt.bitrate && bt.tq))
 685                         return -EINVAL;
 686                 err = can_get_bittiming(dev, &bt);
 687                 if (err)
 688                         return err;
 689                 memcpy(&priv->bittiming, &bt, sizeof(bt));
 690
 691                 if (priv->do_set_bittiming) {
 692                         /* Finally, set the bit-timing registers */
 693                         err = priv->do_set_bittiming(dev);
 694                         if (err)
 695                                 return err;
 696                 }
 697         }
 698
 699         if (data[IFLA_CAN_RESTART_MS]) {
 700                 /* Do not allow changing restart delay while running */
 701                 if (dev->flags & IFF_UP)
 702                         return -EBUSY;
 703                 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
 704         }
 705
 706         if (data[IFLA_CAN_RESTART]) {
 707                 /* Do not allow a restart while not running */
 708                 if (!(dev->flags & IFF_UP))
 709                         return -EINVAL;
 710                 err = can_restart_now(dev);
 711                 if (err)
 712                         return err;
 713         }
 714
 715         return 0;
 716 }
 717
 718 static size_t can_get_size(const struct net_device *dev)
 719 {
 720         struct can_priv *priv = netdev_priv(dev);
 721         size_t size;
 722
 723         size = nla_total_size(sizeof(u32));   /* IFLA_CAN_STATE */
 724         size += sizeof(struct can_ctrlmode);  /* IFLA_CAN_CTRLMODE */
 725         size += nla_total_size(sizeof(u32));  /* IFLA_CAN_RESTART_MS */
 726         size += sizeof(struct can_bittiming); /* IFLA_CAN_BITTIMING */
 727         size += sizeof(struct can_clock);     /* IFLA_CAN_CLOCK */
 728         if (priv->do_get_berr_counter)        /* IFLA_CAN_BERR_COUNTER */
 729                 size += sizeof(struct can_berr_counter);
 730         if (priv->bittiming_const)            /* IFLA_CAN_BITTIMING_CONST */
 731                 size += sizeof(struct can_bittiming_const);
 732
 733         return size;
 734 }
 735
 736 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
 737 {
 738         struct can_priv *priv = netdev_priv(dev);
 739         struct can_ctrlmode cm = {.flags = priv->ctrlmode};
 740         struct can_berr_counter bec;
 741         enum can_state state = priv->state;
 742
 743         if (priv->do_get_state)
 744                 priv->do_get_state(dev, &state);
 745         NLA_PUT_U32(skb, IFLA_CAN_STATE, state);
 746         NLA_PUT(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm);
 747         NLA_PUT_U32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms);
 748         NLA_PUT(skb, IFLA_CAN_BITTIMING,
 749                 sizeof(priv->bittiming), &priv->bittiming);
 750         NLA_PUT(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock);
 751         if (priv->do_get_berr_counter && !priv->do_get_berr_counter(dev, &bec))
 752                 NLA_PUT(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec);
 753         if (priv->bittiming_const)
 754                 NLA_PUT(skb, IFLA_CAN_BITTIMING_CONST,
 755                         sizeof(*priv->bittiming_const), priv->bittiming_const);
 756
 757         return 0;
 758
 759 nla_put_failure:
 760         return -EMSGSIZE;
 761 }
 762
 763 static size_t can_get_xstats_size(const struct net_device *dev)
 764 {
 765         return sizeof(struct can_device_stats);
 766 }
 767
 768 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
 769 {
 770         struct can_priv *priv = netdev_priv(dev);
 771
 772         NLA_PUT(skb, IFLA_INFO_XSTATS,
 773                 sizeof(priv->can_stats), &priv->can_stats);
 774
 775         return 0;
 776
 777 nla_put_failure:
 778         return -EMSGSIZE;
 779 }
 780
 781 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)
 782 static int can_newlink(struct net_device *dev,
 783                        struct nlattr *tb[], struct nlattr *data[])
 784 #else
 785 static int can_newlink(struct net *src_net, struct net_device *dev,
 786                        struct nlattr *tb[], struct nlattr *data[])
 787 #endif
 788 {
 789         return -EOPNOTSUPP;
 790 }
 791
 792 static struct rtnl_link_ops can_link_ops __read_mostly = {
 793         .kind           = "can",
 794         .maxtype        = IFLA_CAN_MAX,
 795         .policy         = can_policy,
 796         .setup          = can_setup,
 797         .newlink        = can_newlink,
 798         .changelink     = can_changelink,
 799         .get_size       = can_get_size,
 800         .fill_info      = can_fill_info,
 801         .get_xstats_size = can_get_xstats_size,
 802         .fill_xstats    = can_fill_xstats,
 803 };
 804
 805 #endif /* !CONFIG_CAN_DEV_SYSFS */
 806
 807 /*
 808  * Register the CAN network device
 809  */
 810 int register_candev(struct net_device *dev)
 811 {
 812 #ifdef CONFIG_CAN_DEV_SYSFS
 813         int err;
 814
 815         err = register_netdev(dev);
 816         if (!err)
 817                 can_create_sysfs(dev);
 818
 819         return err;
 820 #else
 821         dev->rtnl_link_ops = &can_link_ops;
 822         return register_netdev(dev);
 823 #endif
 824 }
 825 EXPORT_SYMBOL_GPL(register_candev);
 826
 827 /*
 828  * Unregister the CAN network device
 829  */
 830 void unregister_candev(struct net_device *dev)
 831 {
 832 #ifdef CONFIG_CAN_DEV_SYSFS
 833         can_remove_sysfs(dev);
 834 #endif
 835         unregister_netdev(dev);
 836 }
 837 EXPORT_SYMBOL_GPL(unregister_candev);
 838
 839 static __init int can_dev_init(void)
 840 {
 841 #ifndef CONFIG_CAN_DEV_SYSFS
 842         int err;
 843
 844         err = rtnl_link_register(&can_link_ops);
 845         if (!err)
 846                 printk(KERN_INFO MOD_DESC "\n");
 847
 848         return err;
 849 #else
 850         printk(KERN_INFO MOD_DESC " using the deprecated SYSFS interface\n");
 851
 852         return 0;
 853 #endif
 854 }
 855 module_init(can_dev_init);
 856
 857 static __exit void can_dev_exit(void)
 858 {
 859 #ifndef CONFIG_CAN_DEV_SYSFS
 860         rtnl_link_unregister(&can_link_ops);
 861 #endif
 862 }
 863 module_exit(can_dev_exit);
 864
 865 #ifndef CONFIG_CAN_DEV_SYSFS
 866 MODULE_ALIAS_RTNL_LINK("can");
 867 #endif