2 * CAN c support to connect to the Linux host SocketCAN interfaces
4 * Copyright (c) 2013-2014 Jin Yang
5 * Copyright (c) 2014-2018 Pavel Pisa
7 * Initial development supported by Google GSoC 2013 from RTEMS project slot
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "qemu/osdep.h"
30 #include "qemu/main-loop.h"
31 #include "qemu/module.h"
32 #include "qapi/error.h"
33 #include "chardev/char.h"
34 #include "qemu/sockets.h"
35 #include "qemu/error-report.h"
36 #include "net/can_emu.h"
37 #include "net/can_host.h"
39 #include <sys/ioctl.h>
41 #include <linux/can.h>
42 #include <linux/can/raw.h>
43 #include "qom/object.h"
49 #define TYPE_CAN_HOST_SOCKETCAN "can-host-socketcan"
50 typedef struct CanHostSocketCAN CanHostSocketCAN
;
51 #define CAN_HOST_SOCKETCAN(obj) \
52 OBJECT_CHECK(CanHostSocketCAN, (obj), TYPE_CAN_HOST_SOCKETCAN)
54 #define CAN_READ_BUF_LEN 5
55 struct CanHostSocketCAN
{
59 qemu_can_filter
*rfilter
;
61 can_err_mask_t err_mask
;
63 qemu_can_frame buf
[CAN_READ_BUF_LEN
];
70 /* Check that QEMU and Linux kernel flags encoding and structure matches */
71 QEMU_BUILD_BUG_ON(QEMU_CAN_EFF_FLAG
!= CAN_EFF_FLAG
);
72 QEMU_BUILD_BUG_ON(QEMU_CAN_RTR_FLAG
!= CAN_RTR_FLAG
);
73 QEMU_BUILD_BUG_ON(QEMU_CAN_ERR_FLAG
!= CAN_ERR_FLAG
);
74 QEMU_BUILD_BUG_ON(QEMU_CAN_INV_FILTER
!= CAN_INV_FILTER
);
75 QEMU_BUILD_BUG_ON(offsetof(qemu_can_frame
, data
)
76 != offsetof(struct can_frame
, data
));
78 static void can_host_socketcan_display_msg(struct qemu_can_frame
*msg
)
81 FILE *logfile
= qemu_log_lock();
82 qemu_log("[cansocketcan]: %03X [%01d] %s %s",
83 msg
->can_id
& QEMU_CAN_EFF_MASK
,
85 msg
->can_id
& QEMU_CAN_EFF_FLAG
? "EFF" : "SFF",
86 msg
->can_id
& QEMU_CAN_RTR_FLAG
? "RTR" : "DAT");
88 for (i
= 0; i
< msg
->can_dlc
; i
++) {
89 qemu_log(" %02X", msg
->data
[i
]);
93 qemu_log_unlock(logfile
);
96 static void can_host_socketcan_read(void *opaque
)
98 CanHostSocketCAN
*c
= opaque
;
99 CanHostState
*ch
= CAN_HOST(c
);
101 /* CAN_READ_BUF_LEN for multiple messages syscall is possible for future */
102 c
->bufcnt
= read(c
->fd
, c
->buf
, sizeof(qemu_can_frame
));
104 warn_report("CAN bus host read failed (%s)", strerror(errno
));
108 can_bus_client_send(&ch
->bus_client
, c
->buf
, 1);
111 can_host_socketcan_display_msg(c
->buf
);
115 static bool can_host_socketcan_can_receive(CanBusClientState
*client
)
120 static ssize_t
can_host_socketcan_receive(CanBusClientState
*client
,
121 const qemu_can_frame
*frames
, size_t frames_cnt
)
123 CanHostState
*ch
= container_of(client
, CanHostState
, bus_client
);
124 CanHostSocketCAN
*c
= CAN_HOST_SOCKETCAN(ch
);
126 size_t len
= sizeof(qemu_can_frame
);
133 res
= write(c
->fd
, frames
, len
);
136 warn_report("[cansocketcan]: write message to host returns zero");
142 warn_report("[cansocketcan]: write to host failed (%s)",
145 warn_report("[cansocketcan]: write to host truncated");
153 static void can_host_socketcan_disconnect(CanHostState
*ch
)
155 CanHostSocketCAN
*c
= CAN_HOST_SOCKETCAN(ch
);
158 qemu_set_fd_handler(c
->fd
, NULL
, NULL
, c
);
168 static CanBusClientInfo can_host_socketcan_bus_client_info
= {
169 .can_receive
= can_host_socketcan_can_receive
,
170 .receive
= can_host_socketcan_receive
,
173 static void can_host_socketcan_connect(CanHostState
*ch
, Error
**errp
)
175 CanHostSocketCAN
*c
= CAN_HOST_SOCKETCAN(ch
);
176 int s
; /* can raw socket */
177 struct sockaddr_can addr
;
181 s
= qemu_socket(PF_CAN
, SOCK_RAW
, CAN_RAW
);
183 error_setg_errno(errp
, errno
, "failed to create CAN_RAW socket");
187 addr
.can_family
= AF_CAN
;
188 memset(&ifr
.ifr_name
, 0, sizeof(ifr
.ifr_name
));
189 strcpy(ifr
.ifr_name
, c
->ifname
);
190 if (ioctl(s
, SIOCGIFINDEX
, &ifr
) < 0) {
191 error_setg_errno(errp
, errno
,
192 "SocketCAN host interface %s not available", c
->ifname
);
195 addr
.can_ifindex
= ifr
.ifr_ifindex
;
197 c
->err_mask
= 0xffffffff; /* Receive error frame. */
198 setsockopt(s
, SOL_CAN_RAW
, CAN_RAW_ERR_FILTER
,
199 &c
->err_mask
, sizeof(c
->err_mask
));
202 c
->rfilter
= g_new(struct qemu_can_filter
, c
->rfilter_num
);
204 /* Receive all data frame. If |= CAN_INV_FILTER no data. */
205 c
->rfilter
[0].can_id
= 0;
206 c
->rfilter
[0].can_mask
= 0;
207 c
->rfilter
[0].can_mask
&= ~CAN_ERR_FLAG
;
209 setsockopt(s
, SOL_CAN_RAW
, CAN_RAW_FILTER
, c
->rfilter
,
210 c
->rfilter_num
* sizeof(struct qemu_can_filter
));
212 if (bind(s
, (struct sockaddr
*)&addr
, sizeof(addr
)) < 0) {
213 error_setg_errno(errp
, errno
, "failed to bind to host interface %s",
219 ch
->bus_client
.info
= &can_host_socketcan_bus_client_info
;
220 qemu_set_fd_handler(c
->fd
, can_host_socketcan_read
, NULL
, c
);
230 static char *can_host_socketcan_get_if(Object
*obj
, Error
**errp
)
232 CanHostSocketCAN
*c
= CAN_HOST_SOCKETCAN(obj
);
234 return g_strdup(c
->ifname
);
237 static void can_host_socketcan_set_if(Object
*obj
, const char *value
, Error
**errp
)
239 CanHostSocketCAN
*c
= CAN_HOST_SOCKETCAN(obj
);
242 if (strlen(value
) >= sizeof(ifr
.ifr_name
)) {
243 error_setg(errp
, "CAN interface name longer than %zd characters",
244 sizeof(ifr
.ifr_name
) - 1);
249 error_setg(errp
, "CAN interface already connected");
254 c
->ifname
= g_strdup(value
);
257 static void can_host_socketcan_instance_init(Object
*obj
)
259 CanHostSocketCAN
*c
= CAN_HOST_SOCKETCAN(obj
);
264 static void can_host_socketcan_class_init(ObjectClass
*klass
,
265 void *class_data G_GNUC_UNUSED
)
267 CanHostClass
*chc
= CAN_HOST_CLASS(klass
);
269 object_class_property_add_str(klass
, "if",
270 can_host_socketcan_get_if
,
271 can_host_socketcan_set_if
);
272 chc
->connect
= can_host_socketcan_connect
;
273 chc
->disconnect
= can_host_socketcan_disconnect
;
276 static const TypeInfo can_host_socketcan_info
= {
277 .parent
= TYPE_CAN_HOST
,
278 .name
= TYPE_CAN_HOST_SOCKETCAN
,
279 .instance_size
= sizeof(CanHostSocketCAN
),
280 .instance_init
= can_host_socketcan_instance_init
,
281 .class_init
= can_host_socketcan_class_init
,
284 static void can_host_register_types(void)
286 type_register_static(&can_host_socketcan_info
);
289 type_init(can_host_register_types
);