kernel/2.6/net/can/can_device.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
  25 #include <linux/can.h>
  26
  27 #include "can_device.h"
  28
  29 /*
  30  Abstract:
  31         Baud rate calculated with next formula:
  32         baud = frq/(brp*(1 + prop_seg+ phase_seg1 + phase_seg2))
  33
  34         This calc function based on work of Florian Hartwich and Armin Bassemi
  35         "The Configuration of the CAN Bit Timing"
  36         (http://www.semiconductors.bosch.de/pdf/CiA99Paper.pdf)
  37
  38  Parameters:
  39   [in]
  40     bit_time_nsec - expected bit time in nanosecs
  41
  42   [out]
  43         bit_time        - calculated time segments, for meaning of
  44                           each field read CAN standart.
  45 */
  46
  47 #define DEFAULT_MAX_BRP                 64U
  48 #define DEFAULT_MAX_SJW                 4U
  49
  50 /* All below values in tq units */
  51 #define MAX_BIT_TIME    25U
  52 #define MIN_BIT_TIME    8U
  53 #define MAX_PROP_SEG    8U
  54 #define MAX_PHASE_SEG1  8U
  55 #define MAX_PHASE_SEG2  8U
  56
  57 int can_calc_bit_time(struct can_device *can, u32 baudrate,
  58                       struct can_bittime_std *bit_time)
  59 {
  60         int best_error = -1; /* Ariphmetic error */
  61         int df, best_df = -1; /* oscillator's tolerance range, greater is better*/
  62         u32 quanta;     /*in tq units*/
  63         u32 brp, phase_seg1, phase_seg2, sjw, prop_seg;
  64         u32 brp_min, brp_max, brp_expected;
  65         u64 tmp;
  66
  67         /* baudrate range [1baud,1Mbaud] */
  68         if (baudrate == 0 || baudrate > 1000000UL)
  69                 return -EINVAL;
  70
  71         tmp = (u64)can->can_sys_clock*1000;
  72         do_div(tmp, baudrate);
  73         brp_expected = (u32)tmp;
  74
  75         brp_min = brp_expected/(1000*MAX_BIT_TIME);
  76         if(brp_min == 0)
  77                 brp_min = 1;
  78         if(brp_min > can->max_brp)
  79                 return -ERANGE;
  80
  81         brp_max = (brp_expected+500*MIN_BIT_TIME)/(1000*MIN_BIT_TIME);
  82         if(brp_max == 0)
  83                 brp_max = 1;
  84         if(brp_max > can->max_brp)
  85                 brp_max = can->max_brp;
  86
  87         for(brp = brp_min; brp <= brp_max; brp++)
  88         {
  89                 quanta = brp_expected/(brp*1000);
  90                 if(quanta<MAX_BIT_TIME && quanta*brp*1000 != brp_expected)
  91                         quanta++;
  92                 if(quanta<MIN_BIT_TIME || quanta>MAX_BIT_TIME)
  93                         continue;
  94
  95                 phase_seg2 = min( (quanta-3)/2, MAX_PHASE_SEG2);
  96                 for(sjw = can->max_sjw; sjw > 0; sjw--)
  97                 {
  98                         for(; phase_seg2>sjw; phase_seg2--)
  99                         {
 100                                 u32 err1, err2;
 101                                 phase_seg1 = (phase_seg2%2)?phase_seg2-1:phase_seg2;
 102                                 prop_seg = quanta-1-phase_seg2-phase_seg1;
 103                                 /* FIXME: support of longer lines (i.e. bigger prop_seg)
 104                                 is more prefered than support of cheap oscillators
 105                                 (i.e. bigger df/phase_seg1/phase_seg2)
 106                                 */
 107                                 if( prop_seg < phase_seg1)
 108                                                 continue;
 109                                 if( prop_seg > MAX_PROP_SEG )
 110                                                 goto next_brp;
 111
 112                                 err1 = phase_seg1*brp*500*1000/
 113                                         (13*brp_expected-phase_seg2*brp*1000);
 114                                 err2 = sjw*brp*50*1000/brp_expected;
 115
 116                                 df = min(err1,err2);
 117                                 if(df>=best_df) {
 118                                         unsigned error = abs(brp_expected*10/
 119                                                            (brp*(1+prop_seg+phase_seg1+phase_seg2))-10000);
 120
 121                                         if( error > 10 || error > best_error )
 122                                                 continue;
 123
 124                                         if( error == best_error && prop_seg < bit_time->prop_seg )
 125                                                 continue;
 126
 127                                         best_error = error;
 128                                         best_df = df;
 129                                         bit_time->brp = brp;
 130                                         bit_time->prop_seg = prop_seg;
 131                                         bit_time->phase_seg1 = phase_seg1;
 132                                         bit_time->phase_seg2 = phase_seg2;
 133                                         bit_time->sjw = sjw;
 134                                         bit_time->sam = ( bit_time->phase_seg1 > 3 )? 1 : 0;
 135                                 }
 136                         }
 137                 }
 138         next_brp:       ;
 139         }
 140
 141         if( best_error < 0 )
 142                 return -EDOM;
 143         return 0;
 144 }
 145 EXPORT_SYMBOL(can_calc_bit_time);
 146
 147 static struct net_device_stats *can_get_stats(struct net_device *dev)
 148 {
 149         return &ND2CAN(dev)->net_stats;
 150 }
 151
 152 static int can_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
 153 {
 154         struct can_device *can = ND2CAN(ndev);
 155         struct can_bittime      *bt = (struct can_bittime *)&ifr->ifr_ifru;
 156         int ret = -EOPNOTSUPP;
 157         ulong *baudrate = (ulong *)&ifr->ifr_ifru;
 158
 159         dev_dbg(ND2D(ndev), "(%s) 0x%08x %p\n", __FUNCTION__, cmd, &ifr->ifr_ifru);
 160
 161         switch (cmd) {
 162         case SIOCSCANBAUDRATE:
 163            if (can->do_set_bit_time) {
 164                         struct can_bittime bit_time;
 165                         ret = can_calc_bit_time(can, *baudrate, &bit_time.std);
 166                         if (ret != 0)
 167                                 break;
 168                         bit_time.type = CAN_BITTIME_STD;
 169                         ret = can->do_set_bit_time(can, &bit_time);
 170                         if ( !ret ) {
 171                                 can->baudrate = *baudrate;
 172                                 can->bit_time = bit_time;
 173                         }
 174                 }
 175                 break;
 176         case SIOCGCANBAUDRATE:
 177                 *baudrate = can->baudrate;
 178                 ret = 0;
 179                 break;
 180         case SIOCSCANCUSTOMBITTIME:
 181                 if (can->do_set_bit_time) {
 182                         ret = can->do_set_bit_time(can, bt);
 183                         if ( !ret ) {
 184                                 can->bit_time = *bt;
 185                                 if (bt->type == CAN_BITTIME_STD && bt->std.brp) {
 186                                   can->baudrate = can->can_sys_clock/(bt->std.brp*
 187                                   (1+bt->std.prop_seg+bt->std.phase_seg1+bt->std.phase_seg2));
 188                                 }
 189                                 else
 190                                         can->baudrate = CAN_BAUDRATE_UNKNOWN;
 191                         }
 192                 }
 193                 break;
 194         case SIOCGCANCUSTOMBITTIME:
 195                 *bt = can->bit_time;
 196                 ret = 0;
 197                 break;
 198         case SIOCSCANMODE:
 199                 if (can->do_set_mode) {
 200                         can_mode_t mode = *((can_mode_t *)(&ifr->ifr_ifru));
 201                         if ( mode == CAN_MODE_START &&
 202                                 can->baudrate == CAN_BAUDRATE_UNCONFIGURED) {
 203                                 dev_info(ND2D(ndev), "Impossible to start on UNKNOWN speed\n");
 204                                 ret = EINVAL;
 205                         }
 206                         else
 207                                 return can->do_set_mode(can, mode);
 208                 }
 209                 break;
 210         case SIOCGCANMODE:
 211                 *((can_mode_t *)(&ifr->ifr_ifru)) = can->mode;
 212                 ret = 0;
 213                 break;
 214         case SIOCSCANCTRLMODE:
 215                 if (can->do_set_ctrlmode) {
 216                         can_ctrlmode_t ctrlmode = *((can_ctrlmode_t *)(&ifr->ifr_ifru));
 217                         return can->do_set_ctrlmode(can, ctrlmode);
 218                 }
 219                 break;
 220         case SIOCGCANCTRLMODE:
 221                 *((can_ctrlmode_t *)(&ifr->ifr_ifru)) = can->ctrlmode;
 222                 ret = 0;
 223                 break;
 224         case SIOCSCANFILTER:
 225                 break;
 226         case SIOCGCANFILTER:
 227                 break;
 228         case SIOCGCANSTATE:
 229                 if(can->do_get_state)
 230                         return can->do_get_state(can, (can_state_t *)(&ifr->ifr_ifru));
 231                 break;
 232         case SIOCGCANSTATS:
 233                 *((struct can_device_stats *)(&ifr->ifr_ifru)) = can->can_stats;
 234                 ret = 0;
 235                 break;
 236         }
 237
 238         return ret;
 239 }
 240
 241 static void can_setup(struct net_device *dev)
 242 {
 243         dev->type = ARPHRD_CAN;
 244
 245         dev->change_mtu                 = NULL;
 246         dev->hard_header                = NULL;
 247         dev->rebuild_header             = NULL;
 248         dev->set_mac_address            = NULL;
 249         dev->hard_header_cache          = NULL;
 250         dev->header_cache_update        = NULL;
 251         dev->hard_header_parse          = NULL;
 252
 253         dev->hard_header_len = 0;
 254
 255         dev->get_stats          = can_get_stats;
 256         dev->mtu                = sizeof(struct can_frame);
 257         dev->do_ioctl           = can_ioctl;
 258         dev->addr_len           = 0;
 259         dev->tx_queue_len       = 10;
 260
 261         /* New-style flags. */
 262         dev->flags      = IFF_NOARP;
 263         dev->features   = NETIF_F_NO_CSUM;
 264 }
 265
 266 /*
 267  * Funciton  alloc_candev
 268  *      Allocates and sets up an CAN device in a manner similar to
 269  *      alloc_etherdev.
 270  */
 271 struct can_device *alloc_candev(int sizeof_priv)
 272 {
 273         struct net_device *ndev;
 274         struct can_device *can;
 275
 276         ndev = alloc_netdev(sizeof_priv+sizeof(struct can_device),
 277                             "can%d", can_setup);
 278         if(!ndev)
 279                 return NULL;
 280
 281         can = netdev_priv(ndev);
 282
 283         can->net_dev = ndev;
 284         if(sizeof_priv)
 285                 can->priv = &can[1];
 286
 287         can->baudrate = CAN_BAUDRATE_UNCONFIGURED;
 288         can->max_brp = DEFAULT_MAX_BRP;
 289         can->max_sjw = DEFAULT_MAX_SJW;
 290         spin_lock_init(&can->irq_lock);
 291
 292         return can;
 293 }
 294 EXPORT_SYMBOL(alloc_candev);
 295
 296 void free_candev(struct can_device *can)
 297 {
 298         free_netdev(can->net_dev);
 299 }
 300 EXPORT_SYMBOL(free_candev);