/* can-calc-bit-timing.c: Calculate CAN bit timing parameters
*
* Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
+ * Copyright (C) 2016 Marc Kleine-Budde <mkl@pengutronix.de>
*
* Derived from:
* can_baud.c - CAN baudrate calculation
#include <errno.h>
#include <getopt.h>
+#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
typedef __u64 u64;
typedef __u32 u32;
+struct calc_ref_clk {
+ __u32 clk; /* CAN system clock frequency in Hz */
+ char *name;
+};
+
struct calc_bittiming_const {
struct can_bittiming_const bittiming_const;
- __u32 ref_clk; /* CAN system clock frequency in Hz */
+ const struct calc_ref_clk ref_clk[16];
void (*printf_btr)(struct can_bittiming *bt, bool hdr);
};
.brp_max = 64,
.brp_inc = 1,
},
- .ref_clk = 8000000,
- .printf_btr = printf_btr_sja1000,
- }, {
- .bittiming_const = {
- .name = "mscan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 64,
- .brp_inc = 1,
- },
- .ref_clk = 32000000,
- .printf_btr = printf_btr_sja1000,
- }, {
- .bittiming_const = {
- .name = "mscan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 64,
- .brp_inc = 1,
- },
- .ref_clk = 33000000,
- .printf_btr = printf_btr_sja1000,
- }, {
- .bittiming_const = {
- .name = "mscan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 64,
- .brp_inc = 1,
- },
- .ref_clk = 33300000,
- .printf_btr = printf_btr_sja1000,
- }, {
- .bittiming_const = {
- .name = "mscan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 64,
- .brp_inc = 1,
+ .ref_clk = {
+ { .clk = 8000000, },
},
- .ref_clk = 33333333,
.printf_btr = printf_btr_sja1000,
}, {
.bittiming_const = {
.brp_max = 64,
.brp_inc = 1,
},
- .ref_clk = 66660000, /* mpc5121 */
- .printf_btr = printf_btr_sja1000,
- }, {
- .bittiming_const = {
- .name = "mscan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 64,
- .brp_inc = 1,
+ .ref_clk = {
+ { .clk = 32000000, },
+ { .clk = 33000000, },
+ { .clk = 33300000, },
+ { .clk = 33333333, },
+ { .clk = 66660000, .name = "mpc5121", },
+ { .clk = 66666666, .name = "mpc5121" },
},
- .ref_clk = 66666666, /* mpc5121 */
.printf_btr = printf_btr_sja1000,
}, {
.bittiming_const = {
.brp_max = 128,
.brp_inc = 1,
},
- .ref_clk = 100000000,
- .printf_btr = printf_btr_at91,
- }, {
- .bittiming_const = {
- .name = "at91",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 2,
- .brp_max = 128,
- .brp_inc = 1,
+ .ref_clk = {
+ { .clk = 99532800, .name = "ronetix PM9263", },
+ { .clk = 100000000, },
},
- /* real world clock as found on the ronetix PM9263 */
- .ref_clk = 99532800,
.printf_btr = printf_btr_at91,
}, {
.bittiming_const = {
.brp_max = 256,
.brp_inc = 1,
},
- .ref_clk = 24000000, /* mx28 */
- .printf_btr = printf_btr_flexcan,
- }, {
- .bittiming_const = {
- .name = "flexcan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 256,
- .brp_inc = 1,
- },
- .ref_clk = 30000000, /* mx6 */
- .printf_btr = printf_btr_flexcan,
- }, {
- .bittiming_const = {
- .name = "flexcan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 256,
- .brp_inc = 1,
- },
- .ref_clk = 49875000,
- .printf_btr = printf_btr_flexcan,
- }, {
- .bittiming_const = {
- .name = "flexcan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 256,
- .brp_inc = 1,
- },
- .ref_clk = 66000000,
- .printf_btr = printf_btr_flexcan,
- }, {
- .bittiming_const = {
- .name = "flexcan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 256,
- .brp_inc = 1,
- },
- .ref_clk = 66500000,
- .printf_btr = printf_btr_flexcan,
- }, {
- .bittiming_const = {
- .name = "flexcan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 256,
- .brp_inc = 1,
+ .ref_clk = {
+ { .clk = 24000000, .name = "mx28" },
+ { .clk = 30000000, .name = "mx6" },
+ { .clk = 49875000, },
+ { .clk = 66000000, },
+ { .clk = 66500000, },
+ { .clk = 66666666, },
+ { .clk = 83368421, .name = "vybrid" },
},
- .ref_clk = 66666666,
.printf_btr = printf_btr_flexcan,
- }, {
- .bittiming_const = {
- .name = "flexcan",
- .tseg1_min = 4,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 256,
- .brp_inc = 1,
- },
- .ref_clk = 83368421,
- .printf_btr = printf_btr_flexcan, /* vybrid */
}, {
.bittiming_const = {
.name = "mcp251x",
.brp_max = 64,
.brp_inc = 1,
},
- .ref_clk = 8000000,
- .printf_btr = printf_btr_mcp251x,
- }, {
- .bittiming_const = {
- .name = "mcp251x",
- .tseg1_min = 3,
- .tseg1_max = 16,
- .tseg2_min = 2,
- .tseg2_max = 8,
- .sjw_max = 4,
- .brp_min = 1,
- .brp_max = 64,
- .brp_inc = 1,
+ .ref_clk = {
+ { .clk = 8000000, },
+ { .clk = 16000000, },
},
- .ref_clk = 16000000,
.printf_btr = printf_btr_mcp251x,
}, {
.bittiming_const = {
.brp_max = 256,
.brp_inc = 1,
},
- .ref_clk = 13000000,
+ .ref_clk = {
+ { .clk = 13000000, },
+ },
.printf_btr = printf_btr_ti_hecc,
}, {
.bittiming_const = {
.brp_max = 1024,
.brp_inc = 1,
},
- .ref_clk = 65000000,
+ .ref_clk = {
+ { .clk = 65000000, },
+ },
.printf_btr = printf_btr_rcar_can,
},
};
};
#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */
+#define CAN_CALC_SYNC_SEG 1
/*
* Bit-timing calculation derived from:
* in the header file linux/can/netlink.h.
*/
static int can_update_spt(const struct can_bittiming_const *btc,
- int sampl_pt, int tseg, int *tseg1, int *tseg2)
+ unsigned int spt_nominal, unsigned int tseg,
+ unsigned int *tseg1_ptr, unsigned int *tseg2_ptr,
+ unsigned int *spt_error_ptr)
{
- *tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000;
- if (*tseg2 < btc->tseg2_min)
- *tseg2 = btc->tseg2_min;
- if (*tseg2 > btc->tseg2_max)
- *tseg2 = btc->tseg2_max;
- *tseg1 = tseg - *tseg2;
- if (*tseg1 > btc->tseg1_max) {
- *tseg1 = btc->tseg1_max;
- *tseg2 = tseg - *tseg1;
+ unsigned int spt_error, best_spt_error = UINT_MAX;
+ unsigned int spt, best_spt = 0;
+ unsigned int tseg1, tseg2;
+ int i;
+
+ for (i = 0; i <= 1; i++) {
+ tseg2 = tseg + CAN_CALC_SYNC_SEG - (spt_nominal * (tseg + CAN_CALC_SYNC_SEG)) / 1000 - i;
+ tseg2 = clamp(tseg2, btc->tseg2_min, btc->tseg2_max);
+ tseg1 = tseg - tseg2;
+ if (tseg1 > btc->tseg1_max) {
+ tseg1 = btc->tseg1_max;
+ tseg2 = tseg - tseg1;
+ }
+
+ spt = 1000 * (tseg + CAN_CALC_SYNC_SEG - tseg2) / (tseg + CAN_CALC_SYNC_SEG);
+ spt_error = abs(spt_nominal - spt);
+
+ if ((spt <= spt_nominal) && (spt_error < best_spt_error)) {
+ best_spt = spt;
+ best_spt_error = spt_error;
+ *tseg1_ptr = tseg1;
+ *tseg2_ptr = tseg2;
+ }
}
- return 1000 * (tseg + 1 - *tseg2) / (tseg + 1);
+
+ if (spt_error_ptr)
+ *spt_error_ptr = best_spt_error;
+
+ return best_spt;
}
static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
const struct can_bittiming_const *btc)
{
struct can_priv *priv = netdev_priv(dev);
- long best_error = 1000000000, error = 0;
- int best_tseg = 0, best_brp = 0, brp = 0;
- int tsegall, tseg = 0, tseg1 = 0, tseg2 = 0;
- int spt_error = 1000, spt = 0, sampl_pt;
- long rate;
+ unsigned int rate; /* current bitrate */
+ unsigned int rate_error; /* difference between current and nominal value */
+ unsigned int best_rate_error = UINT_MAX;
+ unsigned int spt_error; /* difference between current and nominal value */
+ unsigned int best_spt_error = UINT_MAX;
+ unsigned int spt_nominal; /* nominal sample point */
+ unsigned int best_tseg = 0; /* current best value for tseg */
+ unsigned int best_brp = 0; /* current best value for brp */
+ unsigned int brp, tsegall, tseg, tseg1, tseg2;
u64 v64;
/* Use CiA recommended sample points */
if (bt->sample_point) {
- sampl_pt = bt->sample_point;
+ spt_nominal = bt->sample_point;
} else {
if (bt->bitrate > 800000)
- sampl_pt = 750;
+ spt_nominal = 750;
else if (bt->bitrate > 500000)
- sampl_pt = 800;
+ spt_nominal = 800;
else
- sampl_pt = 875;
+ spt_nominal = 875;
}
/* tseg even = round down, odd = round up */
for (tseg = (btc->tseg1_max + btc->tseg2_max) * 2 + 1;
tseg >= (btc->tseg1_min + btc->tseg2_min) * 2; tseg--) {
- tsegall = 1 + tseg / 2;
+ tsegall = CAN_CALC_SYNC_SEG + tseg / 2;
+
/* Compute all possible tseg choices (tseg=tseg1+tseg2) */
brp = priv->clock.freq / (tsegall * bt->bitrate) + tseg % 2;
- /* chose brp step which is possible in system */
+
+ /* choose brp step which is possible in system */
brp = (brp / btc->brp_inc) * btc->brp_inc;
if ((brp < btc->brp_min) || (brp > btc->brp_max))
continue;
+
rate = priv->clock.freq / (brp * tsegall);
- error = bt->bitrate - rate;
+ rate_error = abs(bt->bitrate - rate);
+
/* tseg brp biterror */
- if (error < 0)
- error = -error;
- if (error > best_error)
+ if (rate_error > best_rate_error)
continue;
- best_error = error;
- if (error == 0) {
- spt = can_update_spt(btc, sampl_pt, tseg / 2,
- &tseg1, &tseg2);
- error = sampl_pt - spt;
- if (error < 0)
- error = -error;
- if (error > spt_error)
- continue;
- spt_error = error;
- }
+
+ /* reset sample point error if we have a better bitrate */
+ if (rate_error < best_rate_error)
+ best_spt_error = UINT_MAX;
+
+ can_update_spt(btc, spt_nominal, tseg / 2, &tseg1, &tseg2, &spt_error);
+ if (spt_error > best_spt_error)
+ continue;
+
+ best_spt_error = spt_error;
+ best_rate_error = rate_error;
best_tseg = tseg / 2;
best_brp = brp;
- if (error == 0)
+
+ if (rate_error == 0 && spt_error == 0)
break;
}
- if (best_error) {
+ if (best_rate_error) {
/* Error in one-tenth of a percent */
- error = (best_error * 1000) / bt->bitrate;
- if (error > CAN_CALC_MAX_ERROR) {
+ rate_error = (best_rate_error * 1000) / bt->bitrate;
+ if (rate_error > CAN_CALC_MAX_ERROR) {
netdev_err(dev,
"bitrate error %ld.%ld%% too high\n",
- error / 10, error % 10);
+ rate_error / 10, rate_error % 10);
return -EDOM;
- } else {
- netdev_warn(dev, "bitrate error %ld.%ld%%\n",
- error / 10, error % 10);
}
+ netdev_warn(dev, "bitrate error %ld.%ld%%\n",
+ rate_error / 10, rate_error % 10);
}
/* real sample point */
- bt->sample_point = can_update_spt(btc, sampl_pt, best_tseg,
- &tseg1, &tseg2);
+ bt->sample_point = can_update_spt(btc, spt_nominal, best_tseg,
+ &tseg1, &tseg2, NULL);
- v64 = (u64)best_brp * 1000000000UL;
+ v64 = (u64)best_brp * 1000 * 1000 * 1000;
do_div(v64, priv->clock.freq);
bt->tq = (u32)v64;
bt->prop_seg = tseg1 / 2;
bt->phase_seg2 = tseg2;
/* check for sjw user settings */
- if (!bt->sjw || !btc->sjw_max)
+ if (!bt->sjw || !btc->sjw_max) {
bt->sjw = 1;
- else {
+ } else {
/* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
if (bt->sjw > btc->sjw_max)
bt->sjw = btc->sjw_max;
}
bt->brp = best_brp;
+
/* real bit-rate */
- bt->bitrate = priv->clock.freq / (bt->brp * (tseg1 + tseg2 + 1));
+ bt->bitrate = priv->clock.freq / (bt->brp * (CAN_CALC_SYNC_SEG + tseg1 + tseg2));
return 0;
}
}
static void print_bit_timing(const struct calc_bittiming_const *btc,
- __u32 bitrate, __u32 sample_point, __u32 ref_clk,
+ const struct calc_ref_clk *ref_clk,
+ unsigned int bitrate_nominal,
+ unsigned int spt_nominal,
bool quiet)
{
struct net_device dev = {
- .priv.clock.freq = ref_clk,
+ .priv.clock.freq = ref_clk->clk,
};
struct can_bittiming bt = {
- .bitrate = bitrate,
- .sample_point = sample_point,
+ .bitrate = bitrate_nominal,
+ .sample_point = spt_nominal,
};
long rate_error, spt_error;
if (!quiet) {
- printf("Bit timing parameters for %s with %.6f MHz ref clock\n"
+ printf("Bit timing parameters for %s%s%s%s with %.6f MHz ref clock\n"
"nominal real Bitrt nom real SampP\n"
"Bitrate TQ[ns] PrS PhS1 PhS2 SJW BRP Bitrate Error SampP SampP Error ",
btc->bittiming_const.name,
- ref_clk / 1000000.0);
+ ref_clk->name ? " (" : "",
+ ref_clk->name ? ref_clk->name : "",
+ ref_clk->name ? ")" : "",
+ ref_clk->clk / 1000000.0);
btc->printf_btr(&bt, true);
printf("\n");
}
if (can_calc_bittiming(&dev, &bt, &btc->bittiming_const)) {
- printf("%7d ***bitrate not possible***\n", bitrate);
+ printf("%7d ***bitrate not possible***\n", bitrate_nominal);
return;
}
/* get nominal sample point */
- if (!sample_point)
- sample_point = get_cia_sample_point(bitrate);
+ if (!spt_nominal)
+ spt_nominal = get_cia_sample_point(bitrate_nominal);
- rate_error = abs((__s32)(bitrate - bt.bitrate));
- spt_error = abs((__s32)(sample_point - bt.sample_point));
+ rate_error = abs(bitrate_nominal - bt.bitrate);
+ spt_error = abs(spt_nominal - bt.sample_point);
printf("%7d "
"%6d %3d %4d %4d "
"%3d %3d "
"%7d %4.1f%% "
"%4.1f%% %4.1f%% %4.1f%% ",
- bitrate,
+ bitrate_nominal,
bt.tq, bt.prop_seg, bt.phase_seg1, bt.phase_seg2,
bt.sjw, bt.brp,
bt.bitrate,
- 100.0 * rate_error / bitrate,
+ 100.0 * rate_error / bitrate_nominal,
- sample_point / 10.0,
+ spt_nominal / 10.0,
bt.sample_point / 10.0,
- 100.0 * spt_error / sample_point);
+ 100.0 * spt_error / spt_nominal);
btc->printf_btr(&bt, false);
printf("\n");
int main(int argc, char *argv[])
{
- __u32 bitrate = 0;
- __u32 opt_ref_clk = 0, ref_clk;
- int sampl_pt = 0;
+ __u32 bitrate_nominal = 0;
+ struct calc_ref_clk opt_ref_clk = {
+ .name = "cmd-line",
+ };
+ const struct calc_ref_clk *ref_clk;
+ unsigned int spt_nominal = 0;
bool quiet = false, list = false, found = false;
char *name = NULL;
- unsigned int i, j;
+ unsigned int i, j, k;
int opt;
- const struct calc_bittiming_const *btc = NULL;
+ const struct calc_bittiming_const *btc;
- while ((opt = getopt(argc, argv, "b:c:lps:")) != -1) {
+ while ((opt = getopt(argc, argv, "b:c:lqs:")) != -1) {
switch (opt) {
case 'b':
- bitrate = atoi(optarg);
+ bitrate_nominal = atoi(optarg);
break;
case 'c':
- opt_ref_clk = atoi(optarg);
+ opt_ref_clk.clk = strtoul(optarg, NULL, 10);
break;
case 'l':
break;
case 's':
- sampl_pt = atoi(optarg);
+ spt_nominal = strtoul(optarg, NULL, 10);
break;
default:
exit(EXIT_SUCCESS);
}
- if (sampl_pt && (sampl_pt >= 1000 || sampl_pt < 100))
+ if (spt_nominal && (spt_nominal >= 1000 || spt_nominal < 100))
print_usage(argv[0]);
for (i = 0; i < ARRAY_SIZE(can_calc_consts); i++) {
found = true;
btc = &can_calc_consts[i];
- if (opt_ref_clk)
- ref_clk = opt_ref_clk;
- else
- ref_clk = btc->ref_clk;
-
- if (bitrate) {
- print_bit_timing(btc, bitrate, sampl_pt, ref_clk, quiet);
- } else {
- for (j = 0; j < ARRAY_SIZE(common_bitrates); j++)
- print_bit_timing(btc, common_bitrates[j],
- sampl_pt, ref_clk, j);
+ for (j = 0; j < ARRAY_SIZE(btc->ref_clk); j++) {
+ if (opt_ref_clk.clk)
+ ref_clk = &opt_ref_clk;
+ else
+ ref_clk = &btc->ref_clk[j];
+
+ if (!ref_clk->clk)
+ break;
+
+ if (bitrate_nominal) {
+ print_bit_timing(btc, ref_clk, bitrate_nominal,
+ spt_nominal, quiet);
+ } else {
+ for (k = 0; k < ARRAY_SIZE(common_bitrates); k++)
+ print_bit_timing(btc, ref_clk,
+ common_bitrates[k],
+ spt_nominal, k);
+ }
+ printf("\n");
+
+ if (opt_ref_clk.clk)
+ break;
}
- printf("\n");
}
if (!found) {
projects / can-utils.git / blobdiff