* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
- * Send feedback to <socketcan-users@lists.berlios.de>
+ * Send feedback to <linux-can@vger.kernel.org>
*
*/
#include <unistd.h>
#include <string.h>
#include <signal.h>
+#include <poll.h>
#include <ctype.h>
#include <libgen.h>
#include <time.h>
"- default: %d ms)\n", DEFAULT_GAP);
fprintf(stderr, " -e (generate extended frame mode "
"(EFF) CAN frames)\n");
+ fprintf(stderr, " -f (generate CAN FD CAN frames)\n");
+ fprintf(stderr, " -R (send RTR frame)\n");
+ fprintf(stderr, " -m (mix -e -f -R frames)\n");
fprintf(stderr, " -I <mode> (CAN ID"
" generation mode - see below)\n");
fprintf(stderr, " -L <mode> (CAN data length code (dlc)"
" generation mode - see below)\n");
fprintf(stderr, " -D <mode> (CAN data (payload)"
" generation mode - see below)\n");
+ fprintf(stderr, " -p <timeout> (poll on -ENOBUFS to write frames"
+ " with <timeout> ms)\n");
+ fprintf(stderr, " -n <count> (terminate after <count> CAN frames "
+ "- default infinite)\n");
fprintf(stderr, " -i (ignore -ENOBUFS return values on"
" write() syscalls)\n");
fprintf(stderr, " -x (disable local loopback of "
fprintf(stderr, "(fixed CAN data payload and length)\n");
fprintf(stderr, "%s vcan0 -g 0 -i -x ", prg);
fprintf(stderr, "(full load test ignoring -ENOBUFS)\n");
+ fprintf(stderr, "%s vcan0 -g 0 -p 10 -x ", prg);
+ fprintf(stderr, "(full load test with polling, 10ms timeout)\n");
fprintf(stderr, "%s vcan0 ", prg);
fprintf(stderr, "(my favourite default :)\n\n");
}
int main(int argc, char **argv)
{
- unsigned long gap = DEFAULT_GAP;
+ double gap = DEFAULT_GAP;
+ unsigned long polltimeout = 0;
unsigned char ignore_enobufs = 0;
unsigned char extended = 0;
+ unsigned char canfd = 0;
+ unsigned char mix = 0;
unsigned char id_mode = MODE_RANDOM;
unsigned char data_mode = MODE_RANDOM;
unsigned char dlc_mode = MODE_RANDOM;
unsigned char loopback_disable = 0;
unsigned char verbose = 0;
+ unsigned char rtr_frame = 0;
+ int count = 0;
+ int mtu, maxdlen;
uint64_t incdata = 0;
+ int incdlc = 0;
+ unsigned char fixdata[CANFD_MAX_DLEN];
int opt;
int s; /* socket */
+ struct pollfd fds;
struct sockaddr_can addr;
- static struct can_frame frame;
+ static struct canfd_frame frame;
int nbytes;
int i;
struct ifreq ifr;
struct timespec ts;
+ struct timeval now;
+
+ /* set seed value for pseudo random numbers */
+ gettimeofday(&now, NULL);
+ srandom(now.tv_usec);
signal(SIGTERM, sigterm);
signal(SIGHUP, sigterm);
signal(SIGINT, sigterm);
- while ((opt = getopt(argc, argv, "ig:eI:L:D:xvh?")) != -1) {
+ while ((opt = getopt(argc, argv, "ig:efmI:L:D:xp:n:vRh?")) != -1) {
switch (opt) {
case 'i':
break;
case 'g':
- gap = strtoul(optarg, NULL, 10);
+ gap = strtod(optarg, NULL);
break;
case 'e':
extended = 1;
break;
+ case 'f':
+ canfd = 1;
+ break;
+
+ case 'm':
+ mix = 1;
+ canfd = 1; /* to switch the socket into CAN FD mode */
+ break;
+
case 'I':
if (optarg[0] == 'r') {
id_mode = MODE_RANDOM;
dlc_mode = MODE_INCREMENT;
} else {
dlc_mode = MODE_FIX;
- frame.can_dlc = atoi(optarg)%9;
+ frame.len = atoi(optarg) & 0xFF; /* is cut to 8 / 64 later */
}
break;
data_mode = MODE_INCREMENT;
} else {
data_mode = MODE_FIX;
- if (hexstring2candata(optarg, &frame)) {
+ if (hexstring2data(optarg, fixdata, CANFD_MAX_DLEN)) {
printf ("wrong fix data definition\n");
return 1;
}
loopback_disable = 1;
break;
+ case 'R':
+ rtr_frame = 1;
+ break;
+
+ case 'p':
+ polltimeout = strtoul(optarg, NULL, 10);
+ break;
+
+ case 'n':
+ count = atoi(optarg);
+ if (count < 1) {
+ print_usage(basename(argv[0]));
+ return 1;
+ }
+ break;
+
case '?':
case 'h':
default:
}
ts.tv_sec = gap / 1000;
- ts.tv_nsec = (gap % 1000) * 1000000;
-
- if (id_mode == MODE_FIX) {
+ ts.tv_nsec = ((int)(gap * 1000000)) % 1000000000;
- /* recognize obviously missing commandline option */
- if ((frame.can_id > 0x7FF) && !extended) {
- printf("The given CAN-ID is greater than 0x7FF and "
- "the '-e' option is not set.\n");
- return 1;
- }
-
- if (extended)
- frame.can_id &= CAN_EFF_MASK;
- else
- frame.can_id &= CAN_SFF_MASK;
+ /* recognize obviously missing commandline option */
+ if (id_mode == MODE_FIX && frame.can_id > 0x7FF && !extended) {
+ printf("The given CAN-ID is greater than 0x7FF and "
+ "the '-e' option is not set.\n");
+ return 1;
}
- if (extended)
- frame.can_id |= CAN_EFF_FLAG;
-
- if ((data_mode == MODE_INCREMENT) && !frame.can_dlc)
- frame.can_dlc = 1; /* min dlc value for incr. data */
-
if (strlen(argv[optind]) >= IFNAMSIZ) {
printf("Name of CAN device '%s' is too long!\n\n", argv[optind]);
return 1;
&loopback, sizeof(loopback));
}
+ if (canfd) {
+ int enable_canfd = 1;
+
+ /* check if the frame fits into the CAN netdevice */
+ if (ioctl(s, SIOCGIFMTU, &ifr) < 0) {
+ perror("SIOCGIFMTU");
+ return 1;
+ }
+
+ if (ifr.ifr_mtu != CANFD_MTU) {
+ printf("CAN interface ist not CAN FD capable - sorry.\n");
+ return 1;
+ }
+
+ /* interface is ok - try to switch the socket into CAN FD mode */
+ if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &enable_canfd, sizeof(enable_canfd))){
+ printf("error when enabling CAN FD support\n");
+ return 1;
+ }
+
+ /* ensure discrete CAN FD length values 0..8, 12, 16, 20, 24, 32, 64 */
+ frame.len = can_dlc2len(can_len2dlc(frame.len));
+ } else {
+ /* sanitize CAN 2.0 frame length */
+ if (frame.len > 8)
+ frame.len = 8;
+ }
+
if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("bind");
return 1;
}
- while (running) {
+ if (polltimeout) {
+ fds.fd = s;
+ fds.events = POLLOUT;
+ }
- if (id_mode == MODE_RANDOM) {
+ while (running) {
- frame.can_id = random();
+ if (count && (--count == 0))
+ running = 0;
- if (extended) {
- frame.can_id &= CAN_EFF_MASK;
- frame.can_id |= CAN_EFF_FLAG;
- } else
- frame.can_id &= CAN_SFF_MASK;
+ if (canfd){
+ mtu = CANFD_MTU;
+ maxdlen = CANFD_MAX_DLEN;
+ } else {
+ mtu = CAN_MTU;
+ maxdlen = CAN_MAX_DLEN;
}
- if (dlc_mode == MODE_RANDOM) {
+ if (id_mode == MODE_RANDOM)
+ frame.can_id = random();
- frame.can_dlc = random() & 0xF;
+ if (extended) {
+ frame.can_id &= CAN_EFF_MASK;
+ frame.can_id |= CAN_EFF_FLAG;
+ } else
+ frame.can_id &= CAN_SFF_MASK;
- if (frame.can_dlc & 8)
- frame.can_dlc = 8; /* for about 50% of the frames */
+ if (rtr_frame && !canfd)
+ frame.can_id |= CAN_RTR_FLAG;
- if ((data_mode == MODE_INCREMENT) && !frame.can_dlc)
- frame.can_dlc = 1; /* min dlc value for incr. data */
+ if (dlc_mode == MODE_RANDOM) {
+
+ if (canfd)
+ frame.len = can_dlc2len(random() & 0xF);
+ else {
+ frame.len = random() & 0xF;
+ if (frame.len & 8)
+ frame.len = 8; /* for about 50% of the frames */
+ }
}
+ if (data_mode == MODE_INCREMENT && !frame.len)
+ frame.len = 1; /* min dlc value for incr. data */
+
if (data_mode == MODE_RANDOM) {
/* that's what the 64 bit alignment of data[] is for ... :) */
*(unsigned long*)(&frame.data[0]) = random();
*(unsigned long*)(&frame.data[4]) = random();
+
+ /* omit extra random number generation for CAN FD */
+ if (canfd && frame.len > 8) {
+ memcpy(&frame.data[8], &frame.data[0], 8);
+ memcpy(&frame.data[16], &frame.data[0], 16);
+ memcpy(&frame.data[32], &frame.data[0], 32);
+ }
}
+ if (data_mode == MODE_FIX)
+ memcpy(frame.data, fixdata, CANFD_MAX_DLEN);
+
+ /* set unused payload data to zero like the CAN driver does it on rx */
+ if (frame.len < maxdlen)
+ memset(&frame.data[frame.len], 0, maxdlen - frame.len);
+
if (verbose) {
printf(" %s ", argv[optind]);
if (verbose > 1)
- fprint_long_canframe(stdout, &frame, "\n", (verbose > 2)?1:0);
+ fprint_long_canframe(stdout, &frame, "\n", (verbose > 2)?1:0, maxdlen);
else
- fprint_canframe(stdout, &frame, "\n", 1);
+ fprint_canframe(stdout, &frame, "\n", 1, maxdlen);
}
- nbytes = write(s, &frame, sizeof(struct can_frame));
+resend:
+ nbytes = write(s, &frame, mtu);
if (nbytes < 0) {
if (errno != ENOBUFS) {
perror("write");
return 1;
}
- if (!ignore_enobufs) {
+ if (!ignore_enobufs && !polltimeout) {
perror("write");
return 1;
}
- enobufs_count++;
+ if (polltimeout) {
+ /* wait for the write socket (with timeout) */
+ if (poll(&fds, 1, polltimeout) < 0) {
+ perror("poll");
+ return 1;
+ } else
+ goto resend;
+ } else
+ enobufs_count++;
- } else if (nbytes < sizeof(struct can_frame)) {
+ } else if (nbytes < mtu) {
fprintf(stderr, "write: incomplete CAN frame\n");
return 1;
}
if (nanosleep(&ts, NULL))
return 1;
- if (id_mode == MODE_INCREMENT) {
-
+ if (id_mode == MODE_INCREMENT)
frame.can_id++;
- if (extended) {
- frame.can_id &= CAN_EFF_MASK;
- frame.can_id |= CAN_EFF_FLAG;
- } else
- frame.can_id &= CAN_SFF_MASK;
- }
-
if (dlc_mode == MODE_INCREMENT) {
- frame.can_dlc++;
- frame.can_dlc %= 9;
+ incdlc++;
- if ((data_mode == MODE_INCREMENT) && !frame.can_dlc)
- frame.can_dlc = 1; /* min dlc value for incr. data */
+ if (canfd && !mix) {
+ incdlc &= 0xF;
+ frame.len = can_dlc2len(incdlc);
+ } else {
+ incdlc %= 9;
+ frame.len = incdlc;
+ }
}
if (data_mode == MODE_INCREMENT) {
for (i=0; i<8 ;i++)
frame.data[i] = (incdata >> i*8) & 0xFFULL;
}
+
+ if (mix) {
+ i = random();
+ extended = i&1;
+ canfd = i&2;
+ rtr_frame = ((i&12) == 12); /* reduce RTR frames to 1/4 */
+ }
}
if (enobufs_count)