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  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the version 2 of the GNU General Public License
   9  * as published by the Free Software Foundation
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/if_arp.h>
  24 #include <linux/rtnetlink.h>
  25 #include <linux/can.h>
  26 #include <linux/can/dev.h>
  27
  28 #include "sysfs.h"
  29
  30 #define MOD_DESC "CAN netdevice library"
  31 #define MOD_REV  "20080620"
  32
  33 MODULE_DESCRIPTION(MOD_DESC " (rev " MOD_REV ")");
  34 MODULE_LICENSE("GPL v2");
  35 MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>, "
  36               "Andrey Volkov <avolkov@varma-el.com>");
  37
  38 static int restart_ms;
  39
  40 module_param(restart_ms, int, S_IRUGO | S_IWUSR);
  41
  42 MODULE_PARM_DESC(restart_ms, "Restart time after bus-off in ms (default 0)");
  43
  44
  45 /*
  46  * Abstract:
  47  *   Bit rate calculated with next formula:
  48  *   bitrate = frq/(brp*(1 + prop_seg+ phase_seg1 + phase_seg2))
  49  *
  50  *   This calc function based on work of Florian Hartwich and Armin Bassemi
  51  *   "The Configuration of the CAN Bit Timing"
  52  *   (http://www.semiconductors.bosch.de/pdf/CiA99Paper.pdf)
  53  *
  54  *  Parameters:
  55  *  [in]
  56  *    bittime_nsec - expected bit time in nanosecs
  57  *
  58  *  [out]
  59  *    bittime      - calculated time segments, for meaning of
  60  *                   each field read CAN standard.
  61  */
  62
  63 #define DEFAULT_MAX_BRP 64U
  64 #define DEFAULT_MAX_SJW 4U
  65
  66 /* All below values in tq units */
  67 #define MAX_BITTIME     25U
  68 #define MIN_BITTIME     8U
  69 #define MAX_PROP_SEG    8U
  70 #define MAX_PHASE_SEG1  8U
  71 #define MAX_PHASE_SEG2  8U
  72
  73 int can_calc_bittime(struct can_priv *can, u32 bitrate,
  74                      struct can_bittime_std *bittime)
  75 {
  76         int best_error = -1;    /* Ariphmetic error */
  77         int df, best_df = -1;   /* oscillator's tolerance range,
  78                                    greater is better */
  79         u32 quanta;             /* in tq units */
  80         u32 brp, phase_seg1, phase_seg2, sjw, prop_seg;
  81         u32 brp_min, brp_max, brp_expected;
  82         u64 tmp;
  83
  84         /* bitrate range [1baud,1MiB/s] */
  85         if (bitrate == 0 || bitrate > 1000000UL)
  86                 return -EINVAL;
  87
  88         tmp = (u64) can->can_sys_clock * 1000;
  89         do_div(tmp, bitrate);
  90         brp_expected = (u32) tmp;
  91
  92         brp_min = brp_expected / (1000 * MAX_BITTIME);
  93         if (brp_min == 0)
  94                 brp_min = 1;
  95         if (brp_min > can->max_brp)
  96                 return -ERANGE;
  97
  98         brp_max = (brp_expected + 500 * MIN_BITTIME) / (1000 * MIN_BITTIME);
  99         if (brp_max == 0)
 100                 brp_max = 1;
 101         if (brp_max > can->max_brp)
 102                 brp_max = can->max_brp;
 103
 104         for (brp = brp_min; brp <= brp_max; brp++) {
 105                 quanta = brp_expected / (brp * 1000);
 106                 if (quanta < MAX_BITTIME
 107                     && quanta * brp * 1000 != brp_expected)
 108                         quanta++;
 109                 if (quanta < MIN_BITTIME || quanta > MAX_BITTIME)
 110                         continue;
 111
 112                 phase_seg2 = min((quanta - 3) / 2, MAX_PHASE_SEG2);
 113                 for (sjw = can->max_sjw; sjw > 0; sjw--) {
 114                         for (; phase_seg2 > sjw; phase_seg2--) {
 115                                 u32 err1, err2;
 116                                 phase_seg1 =
 117                                     phase_seg2 % 2 ? phase_seg2 -
 118                                     1 : phase_seg2;
 119                                 prop_seg = quanta - 1 - phase_seg2 - phase_seg1;
 120                                 /*
 121                                  * FIXME: support of longer lines (i.e. bigger
 122                                  * prop_seg) is more prefered than support of
 123                                  * cheap oscillators (i.e. bigger
 124                                  * df/phase_seg1/phase_seg2)
 125                                  */
 126                                 if (prop_seg < phase_seg1)
 127                                         continue;
 128                                 if (prop_seg > MAX_PROP_SEG)
 129                                         goto next_brp;
 130
 131                                 err1 = phase_seg1 * brp * 500 * 1000 /
 132                                     (13 * brp_expected -
 133                                      phase_seg2 * brp * 1000);
 134                                 err2 = sjw * brp * 50 * 1000 / brp_expected;
 135
 136                                 df = min(err1, err2);
 137                                 if (df >= best_df) {
 138                                         unsigned error =
 139                                                 abs(brp_expected * 10 /
 140                                                     (brp * (1 + prop_seg +
 141                                                             phase_seg1 +
 142                                                             phase_seg2)) -
 143                                                     10000);
 144
 145                                         if (error > 10 || error > best_error)
 146                                                 continue;
 147
 148                                         if (error == best_error
 149                                             && prop_seg < bittime->prop_seg)
 150                                                 continue;
 151
 152                                         best_error = error;
 153                                         best_df = df;
 154                                         bittime->brp = brp;
 155                                         bittime->prop_seg = prop_seg;
 156                                         bittime->phase_seg1 = phase_seg1;
 157                                         bittime->phase_seg2 = phase_seg2;
 158                                         bittime->sjw = sjw;
 159                                         bittime->sam =
 160                                                 (bittime->phase_seg1 > 3);
 161                                 }
 162                         }
 163                 }
 164 next_brp:;
 165         }
 166
 167         if (best_error < 0)
 168                 return -EDOM;
 169         return 0;
 170 }
 171
 172 int can_set_bitrate(struct net_device *dev, u32 bitrate)
 173 {
 174         struct can_priv *priv = netdev_priv(dev);
 175         int err = -ENOTSUPP;
 176
 177         if (priv->state != CAN_STATE_STOPPED)
 178                 return -EBUSY;
 179
 180         if (priv->do_set_bittime) {
 181                 if (priv->do_set_bittime) {
 182                         struct can_bittime bittime;
 183                         err = can_calc_bittime(priv, bitrate, &bittime.std);
 184                         if (err)
 185                                 goto out;
 186                         bittime.type = CAN_BITTIME_STD;
 187                         err = priv->do_set_bittime(dev, &bittime);
 188                         if (!err) {
 189                                 priv->bitrate = bitrate;
 190                                 priv->bittime = bittime;
 191                         }
 192                 }
 193         }
 194 out:
 195         return err;
 196 }
 197 EXPORT_SYMBOL(can_set_bitrate);
 198
 199 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 200 static struct net_device_stats *can_get_stats(struct net_device *dev)
 201 {
 202         struct can_priv *priv = netdev_priv(dev);
 203
 204         return &priv->net_stats;
 205 }
 206 #endif
 207
 208 static void can_setup(struct net_device *dev)
 209 {
 210         dev->type = ARPHRD_CAN;
 211         dev->mtu = sizeof(struct can_frame);
 212         dev->hard_header_len = 0;
 213         dev->addr_len = 0;
 214         dev->tx_queue_len = 10;
 215
 216         /* New-style flags. */
 217         dev->flags = IFF_NOARP;
 218         dev->features = NETIF_F_NO_CSUM;
 219 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 220         dev->get_stats = can_get_stats;
 221 #endif
 222 }
 223
 224 /*
 225  * Function  alloc_candev
 226  *      Allocates and sets up an CAN device
 227  */
 228 struct net_device *alloc_candev(int sizeof_priv)
 229 {
 230         struct net_device *dev;
 231         struct can_priv *priv;
 232
 233         dev = alloc_netdev(sizeof_priv, "can%d", can_setup);
 234         if (!dev)
 235                 return NULL;
 236
 237         priv = netdev_priv(dev);
 238
 239         /* Default values can be overwritten by the device driver */
 240         priv->restart_ms = restart_ms;
 241         priv->bitrate = CAN_BITRATE_UNCONFIGURED;
 242         priv->state = CAN_STATE_STOPPED;
 243         priv->max_brp = DEFAULT_MAX_BRP;
 244         priv->max_sjw = DEFAULT_MAX_SJW;
 245         spin_lock_init(&priv->irq_lock);
 246
 247         init_timer(&priv->timer);
 248         priv->timer.expires = 0;
 249
 250         return dev;
 251 }
 252 EXPORT_SYMBOL(alloc_candev);
 253
 254 void free_candev(struct net_device *dev)
 255 {
 256         free_netdev(dev);
 257 }
 258 EXPORT_SYMBOL(free_candev);
 259
 260 /*
 261  * Local echo of CAN messages
 262  *
 263  * CAN network devices *should* support a local echo functionality
 264  * (see Documentation/networking/can.txt). To test the handling of CAN
 265  * interfaces that do not support the local echo both driver types are
 266  * implemented. In the case that the driver does not support the echo
 267  * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core
 268  * to perform the echo as a fallback solution.
 269  */
 270
 271 void can_flush_echo_skb(struct net_device *dev)
 272 {
 273         struct can_priv *priv = netdev_priv(dev);
 274 #ifdef FIXME
 275         struct net_device_stats *stats = dev->get_stats(dev);
 276 #endif
 277         int i;
 278
 279         for (i = 0; i < CAN_ECHO_SKB_MAX; i++) {
 280                 if (priv->echo_skb[i]) {
 281                         kfree_skb(priv->echo_skb[i]);
 282                         priv->echo_skb[i] = NULL;
 283 #ifdef FIXME
 284                         stats->tx_dropped++;
 285                         stats->tx_aborted_errors++;
 286 #endif
 287                 }
 288         }
 289 }
 290
 291 void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev, int idx)
 292 {
 293         struct can_priv *priv = netdev_priv(dev);
 294
 295         /* set flag whether this packet has to be looped back */
 296         if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK) {
 297                 kfree_skb(skb);
 298                 return;
 299         }
 300
 301         if (!priv->echo_skb[idx]) {
 302                 struct sock *srcsk = skb->sk;
 303
 304                 if (atomic_read(&skb->users) != 1) {
 305                         struct sk_buff *old_skb = skb;
 306
 307                         skb = skb_clone(old_skb, GFP_ATOMIC);
 308                         kfree_skb(old_skb);
 309                         if (!skb)
 310                                 return;
 311                 } else
 312                         skb_orphan(skb);
 313
 314                 skb->sk = srcsk;
 315
 316                 /* make settings for echo to reduce code in irq context */
 317                 skb->protocol = htons(ETH_P_CAN);
 318                 skb->pkt_type = PACKET_BROADCAST;
 319                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 320                 skb->dev = dev;
 321
 322                 /* save this skb for tx interrupt echo handling */
 323                 priv->echo_skb[idx] = skb;
 324         } else {
 325                 /* locking problem with netif_stop_queue() ?? */
 326                 printk(KERN_ERR "%s: %s: BUG! echo_skb is occupied!\n",
 327                        dev->name, __func__);
 328                 kfree_skb(skb);
 329         }
 330 }
 331 EXPORT_SYMBOL(can_put_echo_skb);
 332
 333 void can_get_echo_skb(struct net_device *dev, int idx)
 334 {
 335         struct can_priv *priv = netdev_priv(dev);
 336
 337         if ((dev->flags & IFF_ECHO) && priv->echo_skb[idx]) {
 338                 netif_rx(priv->echo_skb[idx]);
 339                 priv->echo_skb[idx] = NULL;
 340         }
 341 }
 342 EXPORT_SYMBOL(can_get_echo_skb);
 343
 344 /*
 345  * CAN bus-off handling
 346  * FIXME: we need some synchronization
 347  */
 348 int can_restart_now(struct net_device *dev)
 349 {
 350         struct can_priv *priv = netdev_priv(dev);
 351         struct net_device_stats *stats = dev->get_stats(dev);
 352         struct sk_buff *skb;
 353         struct can_frame *cf;
 354         int err;
 355
 356         if (netif_carrier_ok(dev))
 357                 netif_carrier_off(dev);
 358
 359         /* Cancel restart in progress */
 360         if (priv->timer.expires) {
 361                 del_timer(&priv->timer);
 362                 priv->timer.expires = 0; /* mark inactive timer */
 363         }
 364
 365         can_flush_echo_skb(dev);
 366
 367         err = priv->do_set_mode(dev, CAN_MODE_START);
 368         if (err)
 369                 return err;
 370
 371         netif_carrier_on(dev);
 372
 373         priv->can_stats.restarts++;
 374
 375         /* send restart message upstream */
 376         skb = dev_alloc_skb(sizeof(struct can_frame));
 377         if (skb == NULL)
 378                 return -ENOMEM;
 379         skb->dev = dev;
 380         skb->protocol = htons(ETH_P_CAN);
 381         cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
 382         memset(cf, 0, sizeof(struct can_frame));
 383         cf->can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
 384         cf->can_dlc = CAN_ERR_DLC;
 385
 386         netif_rx(skb);
 387
 388         dev->last_rx = jiffies;
 389         stats->rx_packets++;
 390         stats->rx_bytes += cf->can_dlc;
 391
 392         return 0;
 393 }
 394
 395 static void can_restart_after(unsigned long data)
 396 {
 397         struct net_device *dev = (struct net_device *)data;
 398         struct can_priv *priv = netdev_priv(dev);
 399
 400         priv->timer.expires = 0; /* mark inactive timer */
 401         can_restart_now(dev);
 402 }
 403
 404 void can_bus_off(struct net_device *dev)
 405 {
 406         struct can_priv *priv = netdev_priv(dev);
 407
 408         netif_carrier_off(dev);
 409
 410         if (priv->restart_ms > 0 && !priv->timer.expires) {
 411
 412                 priv->timer.function = can_restart_after;
 413                 priv->timer.data = (unsigned long)dev;
 414                 priv->timer.expires =
 415                         jiffies + (priv->restart_ms * HZ) / 1000;
 416                 add_timer(&priv->timer);
 417         }
 418 }
 419 EXPORT_SYMBOL(can_bus_off);
 420
 421 void can_close_cleanup(struct net_device *dev)
 422 {
 423         struct can_priv *priv = netdev_priv(dev);
 424
 425         if (priv->timer.expires) {
 426                 del_timer(&priv->timer);
 427                 priv->timer.expires = 0;
 428         }
 429
 430         can_flush_echo_skb(dev);
 431 }
 432 EXPORT_SYMBOL(can_close_cleanup);
 433
 434 static int can_netdev_notifier_call(struct notifier_block *nb,
 435                                     unsigned long state,
 436                                     void *ndev)
 437 {
 438         struct net_device *dev = ndev;
 439         struct can_priv *priv;
 440
 441         if (dev->type != ARPHRD_CAN)
 442                 return 0;
 443
 444         priv = netdev_priv(dev);
 445
 446         /* software CAN devices like 'vcan' do not have private data */
 447         if (!priv)
 448                 return 0;
 449
 450         switch (state) {
 451         case NETDEV_REGISTER:
 452                 /* set default bit timing */
 453                 if (priv->do_set_bittime &&
 454                     priv->bitrate == CAN_BITRATE_UNCONFIGURED) {
 455                         if (can_set_bitrate(dev, CAN_BITRATE_DEFAULT))
 456                                 dev_err(ND2D(dev), "failed to set bitrate\n");
 457                 }
 458 #ifdef CONFIG_SYSFS
 459                 can_create_sysfs(dev);
 460 #endif
 461                 break;
 462         case NETDEV_UNREGISTER:
 463 #ifdef CONFIG_SYSFS
 464                 can_remove_sysfs(dev);
 465 #endif
 466                 break;
 467         }
 468         return 0;
 469 }
 470
 471 static struct notifier_block can_netdev_notifier = {
 472         .notifier_call = can_netdev_notifier_call,
 473 };
 474
 475 static __init int can_dev_init(void)
 476 {
 477         printk(KERN_INFO MOD_DESC " (rev " MOD_REV ")\n");
 478
 479         return register_netdevice_notifier(&can_netdev_notifier);
 480 }
 481 module_init(can_dev_init);
 482
 483 static __exit void can_dev_exit(void)
 484 {
 485         unregister_netdevice_notifier(&can_netdev_notifier);
 486 }
 487 module_exit(can_dev_exit);