584 lines
15 KiB
C
584 lines
15 KiB
C
/* $NetBSD: canconfig.c,v 1.2 2017/05/27 21:02:55 bouyer Exp $ */
|
|
|
|
/*
|
|
* Copyright 2001 Wasabi Systems, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Written by Jason R. Thorpe for Wasabi Systems, Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed for the NetBSD Project by
|
|
* Wasabi Systems, Inc.
|
|
* 4. The name of Wasabi Systems, Inc. may not be used to endorse
|
|
* or promote products derived from this software without specific prior
|
|
* written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: canconfig.c,v 1.2 2017/05/27 21:02:55 bouyer Exp $");
|
|
#endif
|
|
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <net/if.h>
|
|
#include <netcan/can.h>
|
|
#include <netcan/can_link.h>
|
|
#include <ifaddrs.h>
|
|
|
|
#include <ctype.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
struct command {
|
|
const char *cmd_keyword;
|
|
int cmd_argcnt;
|
|
int cmd_flags;
|
|
void (*cmd_func)(const struct command *, int, const char *,
|
|
char **);
|
|
};
|
|
|
|
#define CMD_INVERT 0x01 /* "invert" the sense of the command */
|
|
|
|
static void cmd_up(const struct command *, int, const char *, char **);
|
|
static void cmd_down(const struct command *, int, const char *, char **);
|
|
static void cmd_brp(const struct command *, int, const char *, char **);
|
|
static void cmd_prop_seg(const struct command *, int, const char *, char **);
|
|
static void cmd_phase_seg1(const struct command *, int, const char *, char **);
|
|
static void cmd_phase_seg2(const struct command *, int, const char *, char **);
|
|
static void cmd_sjw(const struct command *, int, const char *, char **);
|
|
static void cmd_3samples(const struct command *, int, const char *, char **);
|
|
static void cmd_listenonly(const struct command *, int, const char *, char **);
|
|
static void cmd_loopback(const struct command *, int, const char *, char **);
|
|
|
|
static const struct command command_table[] = {
|
|
{ "up", 0, 0, cmd_up },
|
|
{ "down", 0, 0, cmd_down },
|
|
|
|
{ "brp", 1, 0, cmd_brp },
|
|
{ "prop_seg", 1, 0, cmd_prop_seg },
|
|
{ "phase_seg1", 1, 0, cmd_phase_seg1 },
|
|
{ "phase_seg2", 1, 0, cmd_phase_seg2 },
|
|
{ "sjw", 1, 0, cmd_sjw },
|
|
|
|
{ "3samples", 0, 0, cmd_3samples },
|
|
{ "-3samples", 0, CMD_INVERT, cmd_3samples },
|
|
|
|
{ "listenonly", 0, 0, cmd_listenonly },
|
|
{ "-listenonly", 0, CMD_INVERT, cmd_listenonly },
|
|
|
|
{ "loopback", 0, 0, cmd_loopback },
|
|
{ "-loopback", 0, CMD_INVERT, cmd_loopback },
|
|
|
|
{ NULL, 0, 0, NULL },
|
|
};
|
|
|
|
static void printall(int);
|
|
static void status(int, const char *);
|
|
static void show_timings(int, const char *, const char *);
|
|
static int is_can(int s, const char *);
|
|
static int get_val(const char *, u_long *);
|
|
#define do_cmd(a,b,c,d,e,f) do_cmd2((a),(b),(c),(d),(e),NULL,(f))
|
|
static int do_cmd2(int, const char *, u_long, void *, size_t, size_t *, int);
|
|
__dead static void usage(void);
|
|
|
|
static int aflag;
|
|
static struct ifreq g_ifr;
|
|
static int g_ifr_updated = 0;
|
|
|
|
struct can_link_timecaps g_cltc;
|
|
struct can_link_timings g_clt;
|
|
static int g_clt_updated = 0;
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
const struct command *cmd;
|
|
char *canifname;
|
|
int sock, ch;
|
|
|
|
if (argc < 2)
|
|
usage();
|
|
|
|
while ((ch = getopt(argc, argv, "a")) != -1) {
|
|
switch (ch) {
|
|
case 'a':
|
|
aflag = 1;
|
|
break;
|
|
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (aflag) {
|
|
if (argc != 0)
|
|
usage();
|
|
sock = socket(AF_CAN, SOCK_RAW, CAN_RAW);
|
|
if (sock < 0)
|
|
err(1, "socket");
|
|
|
|
printall(sock);
|
|
exit(0);
|
|
}
|
|
|
|
if (argc == 0)
|
|
usage();
|
|
|
|
sock = socket(AF_CAN, SOCK_RAW, CAN_RAW);
|
|
if (sock < 0)
|
|
err(1, "socket");
|
|
|
|
canifname = argv[0];
|
|
|
|
if (is_can(sock, canifname) == 0)
|
|
errx(1, "%s is not a can interface", canifname);
|
|
|
|
/* Get a copy of the interface flags. */
|
|
strlcpy(g_ifr.ifr_name, canifname, sizeof(g_ifr.ifr_name));
|
|
if (ioctl(sock, SIOCGIFFLAGS, &g_ifr) < 0)
|
|
err(1, "unable to get interface flags");
|
|
|
|
argc--;
|
|
argv++;
|
|
|
|
if (argc == 0) {
|
|
status(sock, canifname);
|
|
exit(0);
|
|
}
|
|
|
|
if (do_cmd(sock, canifname, CANGLINKTIMECAP, &g_cltc, sizeof(g_cltc), 0)
|
|
< 0)
|
|
err(1, "unable to get can link timecaps");
|
|
|
|
if (do_cmd(sock, canifname, CANGLINKTIMINGS, &g_clt, sizeof(g_clt), 0) < 0)
|
|
err(1, "unable to get can link timings");
|
|
|
|
while (argc != 0) {
|
|
for (cmd = command_table; cmd->cmd_keyword != NULL; cmd++) {
|
|
if (strcmp(cmd->cmd_keyword, argv[0]) == 0)
|
|
break;
|
|
}
|
|
if (cmd->cmd_keyword == NULL)
|
|
errx(1, "unknown command: %s", argv[0]);
|
|
|
|
argc--;
|
|
argv++;
|
|
|
|
if (argc < cmd->cmd_argcnt)
|
|
errx(1, "command %s requires %d argument%s",
|
|
cmd->cmd_keyword, cmd->cmd_argcnt,
|
|
cmd->cmd_argcnt == 1 ? "" : "s");
|
|
|
|
(*cmd->cmd_func)(cmd, sock, canifname, argv);
|
|
|
|
argc -= cmd->cmd_argcnt;
|
|
argv += cmd->cmd_argcnt;
|
|
}
|
|
|
|
/* If the timings changed, update them. */
|
|
if (g_clt_updated &&
|
|
do_cmd(sock, canifname, CANSLINKTIMINGS, &g_clt, sizeof(g_clt), 1) < 0)
|
|
err(1, "unable to set can link timings");
|
|
|
|
/* If the flags changed, update them. */
|
|
if (g_ifr_updated && ioctl(sock, SIOCSIFFLAGS, &g_ifr) < 0)
|
|
err(1, "unable to set interface flags");
|
|
|
|
exit (0);
|
|
}
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
static const char *usage_strings[] = {
|
|
"-a",
|
|
"<canif>",
|
|
"<canif> up|down",
|
|
"<canif> brp <value>",
|
|
"<canif> prop_seg <value>",
|
|
"<canif> phase_seg1 <value>",
|
|
"<canif> phase_seg2 <value>",
|
|
"<canif> sjw <value>",
|
|
"<canif> 3samples | -3samples",
|
|
"<canif> listenonly | -listenonly",
|
|
"<canif> loopback | -loopback",
|
|
NULL,
|
|
};
|
|
extern const char *__progname;
|
|
int i;
|
|
|
|
for (i = 0; usage_strings[i] != NULL; i++)
|
|
fprintf(stderr, "%s %s %s\n",
|
|
i == 0 ? "usage:" : " ",
|
|
__progname, usage_strings[i]);
|
|
|
|
exit(1);
|
|
}
|
|
|
|
static int
|
|
is_can(int s, const char *canif)
|
|
{
|
|
uint32_t linkmode;
|
|
|
|
if (do_cmd(s, canif, CANGLINKMODE, &linkmode, sizeof(linkmode), 0) < 0)
|
|
return (0);
|
|
|
|
return (1);
|
|
}
|
|
|
|
static void
|
|
printb(const char *s, u_int v, const char *bits)
|
|
{
|
|
int i, any = 0;
|
|
char c;
|
|
|
|
if (bits && *bits == 8)
|
|
printf("%s=%o", s, v);
|
|
else
|
|
printf("%s=%x", s, v);
|
|
if (bits) {
|
|
bits++;
|
|
putchar('<');
|
|
while ((i = *bits++) != 0) {
|
|
if (v & (1 << (i-1))) {
|
|
if (any)
|
|
putchar(',');
|
|
any = 1;
|
|
for (; (c = *bits) > 32; bits++)
|
|
putchar(c);
|
|
} else
|
|
for (; *bits > 32; bits++)
|
|
;
|
|
}
|
|
putchar('>');
|
|
}
|
|
}
|
|
|
|
static void
|
|
printall(int sock)
|
|
{
|
|
struct ifaddrs *ifap, *ifa;
|
|
char *p;
|
|
|
|
if (getifaddrs(&ifap) != 0)
|
|
err(1, "getifaddrs");
|
|
p = NULL;
|
|
for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
|
|
if (is_can(sock, ifa->ifa_name) == 0)
|
|
continue;
|
|
if (p != NULL && strcmp(p, ifa->ifa_name) == 0)
|
|
continue;
|
|
p = ifa->ifa_name;
|
|
status(sock, ifa->ifa_name);
|
|
}
|
|
|
|
freeifaddrs(ifap);
|
|
}
|
|
|
|
static void
|
|
status(int sock, const char *canifname)
|
|
{
|
|
struct ifreq ifr;
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
|
|
strlcpy(ifr.ifr_name, canifname, sizeof(ifr.ifr_name));
|
|
if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0)
|
|
err(1, "unable to get flags");
|
|
|
|
printf("%s: ", canifname);
|
|
printb("flags", ifr.ifr_flags, IFFBITS);
|
|
printf("\n");
|
|
|
|
show_timings(sock, canifname, "\t");
|
|
|
|
}
|
|
|
|
static int
|
|
valid_timings(struct can_link_timecaps *cltc, struct can_link_timings *clt)
|
|
{
|
|
if (clt->clt_brp < cltc->cltc_brp_min ||
|
|
clt->clt_brp > cltc->cltc_brp_max)
|
|
return 0;
|
|
|
|
if (clt->clt_prop < cltc->cltc_prop_min ||
|
|
clt->clt_prop > cltc->cltc_prop_max)
|
|
return 0;
|
|
|
|
if (clt->clt_ps1 < cltc->cltc_ps1_min ||
|
|
clt->clt_ps1 > cltc->cltc_ps1_max)
|
|
return 0;
|
|
|
|
if (clt->clt_ps2 < cltc->cltc_ps2_min ||
|
|
clt->clt_ps2 > cltc->cltc_ps2_max)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
show_timings(int sock, const char *canifname, const char *prefix)
|
|
{
|
|
struct can_link_timecaps cltc;
|
|
struct can_link_timings clt;
|
|
u_int32_t linkmode;
|
|
char hbuf[8];
|
|
|
|
if (do_cmd(sock, canifname, CANGLINKTIMECAP, &cltc, sizeof(cltc), 0)
|
|
< 0)
|
|
err(1, "unable to get can link timecaps");
|
|
|
|
if (do_cmd(sock, canifname, CANGLINKTIMINGS, &clt, sizeof(clt), 0) < 0)
|
|
err(1, "unable to get can link timings");
|
|
|
|
if (do_cmd(sock, canifname, CANGLINKMODE, &linkmode, sizeof(linkmode),
|
|
0) < 0)
|
|
err(1, "unable to get can link mode");
|
|
|
|
humanize_number(hbuf, sizeof(hbuf), cltc.cltc_clock_freq, "Hz",
|
|
HN_AUTOSCALE, HN_NOSPACE | HN_DIVISOR_1000);
|
|
|
|
printf("%stiming caps:\n", prefix);
|
|
printf("%s clock %s, brp [%d..%d]/%d, prop_seg [%d..%d]\n",
|
|
prefix, hbuf,
|
|
cltc.cltc_brp_min, cltc.cltc_brp_max, cltc.cltc_brp_inc,
|
|
cltc.cltc_prop_min, cltc.cltc_prop_max);
|
|
printf("%s phase_seg1 [%d..%d], phase_seg2 [%d..%d], sjw [0..%d]\n",
|
|
prefix,
|
|
cltc.cltc_ps1_min, cltc.cltc_ps1_max,
|
|
cltc.cltc_ps2_min, cltc.cltc_ps2_max,
|
|
cltc.cltc_sjw_max);
|
|
printf("%s ", prefix);
|
|
printb("capabilities", cltc.cltc_linkmode_caps, CAN_IFFBITS);
|
|
printf("\n");
|
|
printf("%soperational timings:", prefix);
|
|
if (valid_timings(&cltc, &clt)) {
|
|
uint32_t tq, ntq, bps;
|
|
tq = ((uint64_t)clt.clt_brp * (uint64_t)1000000000) /
|
|
cltc.cltc_clock_freq;
|
|
ntq = 1 + clt.clt_prop + clt.clt_ps1 + clt.clt_ps2;
|
|
printf(" %d time quanta of %dns",
|
|
1 + clt.clt_prop + clt.clt_ps1 + clt.clt_ps2, tq);
|
|
bps = 1000000000 / (tq * ntq);
|
|
humanize_number(hbuf, sizeof(hbuf), bps, "bps",
|
|
HN_AUTOSCALE, HN_NOSPACE | HN_DIVISOR_1000);
|
|
printf(", %s", hbuf);
|
|
};
|
|
printf("\n");
|
|
|
|
printf("%s brp %d, prop_seg %d, phase_seg1 %d, phase_seg2 %d, sjw %d\n",
|
|
prefix,
|
|
clt.clt_brp, clt.clt_prop, clt.clt_ps1, clt.clt_ps2, clt.clt_sjw);
|
|
printf("%s ", prefix);
|
|
printb("mode", linkmode, CAN_IFFBITS);
|
|
printf("\n");
|
|
}
|
|
|
|
static int
|
|
get_val(const char *cp, u_long *valp)
|
|
{
|
|
char *endptr;
|
|
u_long val;
|
|
|
|
errno = 0;
|
|
val = strtoul(cp, &endptr, 0);
|
|
if (cp[0] == '\0' || endptr[0] != '\0' || errno == ERANGE)
|
|
return (-1);
|
|
|
|
*valp = val;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
do_cmd2(int sock, const char *canifname, u_long op, void *arg, size_t argsize,
|
|
size_t *outsizep, int set)
|
|
{
|
|
struct ifdrv ifd;
|
|
int error;
|
|
|
|
memset(&ifd, 0, sizeof(ifd));
|
|
|
|
strlcpy(ifd.ifd_name, canifname, sizeof(ifd.ifd_name));
|
|
ifd.ifd_cmd = op;
|
|
ifd.ifd_len = argsize;
|
|
ifd.ifd_data = arg;
|
|
|
|
error = ioctl(sock, set ? SIOCSDRVSPEC : SIOCGDRVSPEC, &ifd);
|
|
|
|
if (outsizep)
|
|
*outsizep = ifd.ifd_len;
|
|
|
|
return error;
|
|
}
|
|
|
|
static void
|
|
do_ifflag(int sock, const char *canifname, int flag, int set)
|
|
{
|
|
|
|
if (set)
|
|
g_ifr.ifr_flags |= flag;
|
|
else
|
|
g_ifr.ifr_flags &= ~flag;
|
|
|
|
g_ifr_updated = 1;
|
|
}
|
|
|
|
static int
|
|
do_canflag(int sock, const char *canifname, uint32_t flag, int set)
|
|
{
|
|
int cmd;
|
|
if (set)
|
|
cmd = CANSLINKMODE;
|
|
else
|
|
cmd = CANCLINKMODE;
|
|
return do_cmd(sock, canifname, cmd, &flag, sizeof(flag), 1);
|
|
}
|
|
|
|
static void
|
|
cmd_up(const struct command *cmd, int sock, const char *canifname,
|
|
char **argv)
|
|
{
|
|
|
|
do_ifflag(sock, canifname, IFF_UP, 1);
|
|
}
|
|
|
|
static void
|
|
cmd_down(const struct command *cmd, int sock, const char *canifname,
|
|
char **argv)
|
|
{
|
|
|
|
do_ifflag(sock, canifname, IFF_UP, 0);
|
|
}
|
|
|
|
static void
|
|
cmd_brp(const struct command *cmd, int sock, const char *bridge,
|
|
char **argv)
|
|
{
|
|
u_long val;
|
|
|
|
if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
|
|
errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
|
|
if (val < g_cltc.cltc_brp_min || val > g_cltc.cltc_brp_max)
|
|
errx(1, "%s: out of range value: %s", cmd->cmd_keyword, argv[0]);
|
|
g_clt.clt_brp = val;
|
|
g_clt_updated=1;
|
|
}
|
|
|
|
static void
|
|
cmd_prop_seg(const struct command *cmd, int sock, const char *bridge,
|
|
char **argv)
|
|
{
|
|
u_long val;
|
|
|
|
if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
|
|
errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
|
|
if (val < g_cltc.cltc_prop_min || val > g_cltc.cltc_prop_max)
|
|
errx(1, "%s: out of range value: %s", cmd->cmd_keyword, argv[0]);
|
|
g_clt.clt_prop = val;
|
|
g_clt_updated=1;
|
|
}
|
|
|
|
static void
|
|
cmd_phase_seg1(const struct command *cmd, int sock, const char *bridge,
|
|
char **argv)
|
|
{
|
|
u_long val;
|
|
|
|
if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
|
|
errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
|
|
if (val < g_cltc.cltc_ps1_min || val > g_cltc.cltc_ps1_max)
|
|
errx(1, "%s: out of range value: %s", cmd->cmd_keyword, argv[0]);
|
|
g_clt.clt_ps1 = val;
|
|
g_clt_updated=1;
|
|
}
|
|
|
|
static void
|
|
cmd_phase_seg2(const struct command *cmd, int sock, const char *bridge,
|
|
char **argv)
|
|
{
|
|
u_long val;
|
|
|
|
if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
|
|
errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
|
|
if (val < g_cltc.cltc_ps2_min || val > g_cltc.cltc_ps2_max)
|
|
errx(1, "%s: out of range value: %s", cmd->cmd_keyword, argv[0]);
|
|
g_clt.clt_ps2 = val;
|
|
g_clt_updated=1;
|
|
}
|
|
|
|
static void
|
|
cmd_sjw(const struct command *cmd, int sock, const char *bridge,
|
|
char **argv)
|
|
{
|
|
u_long val;
|
|
|
|
if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
|
|
errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
|
|
if (val > g_cltc.cltc_sjw_max)
|
|
errx(1, "%s: out of range value: %s", cmd->cmd_keyword, argv[0]);
|
|
g_clt.clt_sjw = val;
|
|
g_clt_updated=1;
|
|
}
|
|
static void
|
|
cmd_3samples(const struct command *cmd, int sock, const char *canifname,
|
|
char **argv)
|
|
{
|
|
if (do_canflag(sock, canifname, CAN_LINKMODE_3SAMPLES,
|
|
(cmd->cmd_flags & CMD_INVERT) ? 0 : 1) < 0)
|
|
err(1, "%s", cmd->cmd_keyword);
|
|
|
|
}
|
|
|
|
static void
|
|
cmd_listenonly(const struct command *cmd, int sock, const char *canifname,
|
|
char **argv)
|
|
{
|
|
if (do_canflag(sock, canifname, CAN_LINKMODE_LISTENONLY,
|
|
(cmd->cmd_flags & CMD_INVERT) ? 0 : 1) < 0)
|
|
err(1, "%s", cmd->cmd_keyword);
|
|
|
|
}
|
|
|
|
static void
|
|
cmd_loopback(const struct command *cmd, int sock, const char *canifname,
|
|
char **argv)
|
|
{
|
|
if (do_canflag(sock, canifname, CAN_LINKMODE_LOOPBACK,
|
|
(cmd->cmd_flags & CMD_INVERT) ? 0 : 1) < 0)
|
|
err(1, "%s", cmd->cmd_keyword);
|
|
|
|
}
|