* 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, the following disclaimer and
- * the referenced file 'COPYING'.
+ * 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.
*
* Alternatively, provided that this notice is retained in full, this
* software may be distributed under the terms of the GNU General
- * Public License ("GPL") version 2 as distributed in the 'COPYING'
- * file from the main directory of the linux kernel source.
+ * Public License ("GPL") version 2, in which case the provisions of the
+ * GPL apply INSTEAD OF those given above.
*
* The provided data structures and external interfaces from this code
* are not restricted to be used by modules with a GPL compatible license.
*
*/
-#include <linux/autoconf.h>
#include <linux/module.h>
+#include <linux/version.h>
#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/hrtimer.h>
+#include <linux/list.h>
+#include <linux/proc_fs.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+#include <linux/seq_file.h>
+#endif
+#include <linux/uio.h>
#include <linux/net.h>
#include <linux/netdevice.h>
-#include <linux/proc_fs.h>
-#include <linux/poll.h>
+#include <linux/socket.h>
+#include <linux/if_arp.h>
+#include <linux/skbuff.h>
+#include <socketcan/can.h>
+#include <socketcan/can/core.h>
+#include <socketcan/can/bcm.h>
#include <net/sock.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
+#include <net/net_namespace.h>
+#endif
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
+#include "compat.h"
+#endif
-#include <linux/can.h>
-#include <linux/can/core.h>
-#include <linux/can/bcm.h>
-
-#include <linux/can/version.h> /* for RCSID. Removed by mkpatch script */
+#include <socketcan/can/version.h> /* for RCSID. Removed by mkpatch script */
RCSID("$Id$");
-#ifdef CONFIG_CAN_DEBUG_CORE
-static int debug = 0;
-module_param(debug, int, S_IRUGO);
-#define DBG(args...) (debug & 1 ? \
- (printk(KERN_DEBUG "BCM %s: ", __func__), \
- printk(args)) : 0)
-#define DBG_FRAME(args...) (debug & 2 ? can_debug_cframe(args) : 0)
-#define DBG_SKB(skb) (debug & 4 ? can_debug_skb(skb) : 0)
-#else
-#define DBG(args...)
-#define DBG_FRAME(args...)
-#define DBG_SKB(skb)
-#endif
+/*
+ * To send multiple CAN frame content within TX_SETUP or to filter
+ * CAN messages with multiplex index within RX_SETUP, the number of
+ * different filters is limited to 256 due to the one byte index value.
+ */
+#define MAX_NFRAMES 256
/* use of last_frames[index].can_dlc */
#define RX_RECV 0x40 /* received data for this element */
#define BCM_CAN_DLC_MASK 0x0F /* clean private flags in can_dlc by masking */
/* get best masking value for can_rx_register() for a given single can_id */
-#define REGMASK(id) ((id & CAN_RTR_FLAG) | ((id & CAN_EFF_FLAG) ? \
- (CAN_EFF_MASK | CAN_EFF_FLAG) : CAN_SFF_MASK))
+#define REGMASK(id) ((id & CAN_EFF_FLAG) ? \
+ (CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG) : \
+ (CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG))
-#define IDENT "bcm"
+#define CAN_BCM_VERSION CAN_VERSION
static __initdata const char banner[] = KERN_INFO
- "CAN: broadcast manager (bcm) socket protocol " CAN_VERSION "\n";
+ "can: broadcast manager protocol (rev " CAN_BCM_VERSION " t)\n";
-MODULE_DESCRIPTION("PF_CAN bcm sockets");
+MODULE_DESCRIPTION("PF_CAN broadcast manager protocol");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
+MODULE_ALIAS("can-proto-2");
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
+#error This code only supports Kernel versions 2.6.22+
+#error For older 2.6 Kernels please use bcm-prior-2-6-22.c instead of bcm.c
+#endif
-#define GET_U64(p) (*(u64*)(p)->data) /* easy access */
+/* easy access to can_frame payload */
+static inline u64 GET_U64(const struct can_frame *cp)
+{
+ return *(u64 *)cp->data;
+}
struct bcm_op {
struct list_head list;
int ifindex;
canid_t can_id;
- int flags;
- unsigned long j_ival1, j_ival2, j_lastmsg;
+ u32 flags;
unsigned long frames_abs, frames_filtered;
- struct timer_list timer, thrtimer;
struct timeval ival1, ival2;
- struct timeval rx_stamp;
+ struct hrtimer timer, thrtimer;
+ struct tasklet_struct tsklet, thrtsklet;
+ ktime_t rx_stamp, kt_ival1, kt_ival2, kt_lastmsg;
int rx_ifindex;
- int count;
- int nframes;
- int currframe;
+ u32 count;
+ u32 nframes;
+ u32 currframe;
struct can_frame *frames;
struct can_frame *last_frames;
+ struct can_frame sframe;
+ struct can_frame last_sframe;
struct sock *sk;
+ struct net_device *rx_reg_dev;
};
-struct bcm_opt {
+static struct proc_dir_entry *proc_dir;
+
+struct bcm_sock {
+ struct sock sk;
int bound;
int ifindex;
+ struct notifier_block notifier;
struct list_head rx_ops;
struct list_head tx_ops;
unsigned long dropped_usr_msgs;
struct proc_dir_entry *bcm_proc_read;
- char procname [9]; /* pointer printed in ASCII with \0 */
-};
-
-static struct proc_dir_entry *proc_dir = NULL;
-
-static int bcm_init(struct sock *sk);
-static void bcm_notifier(unsigned long msg, void *data);
-static int bcm_release(struct socket *sock);
-static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len,
- int flags);
-static int bcm_sendmsg(struct kiocb *iocb, struct socket *sock,
- struct msghdr *msg, size_t size);
-static int bcm_recvmsg(struct kiocb *iocb, struct socket *sock,
- struct msghdr *msg, size_t size, int flags);
-static unsigned int bcm_poll(struct file *file, struct socket *sock,
- poll_table *wait);
-
-static int bcm_read_proc(char *page, char **start, off_t off,
- int count, int *eof, void *data);
-
-static void bcm_tx_timeout_handler(unsigned long data);
-static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk);
-static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
- int ifindex, struct sock *sk);
-static void bcm_can_tx(struct bcm_op *op);
-
-static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
- int ifindex, struct sock *sk);
-static void bcm_rx_handler(struct sk_buff *skb, void *op);
-static void bcm_rx_timeout_handler(unsigned long data);
-static void bcm_rx_thr_handler(unsigned long data);
-static void bcm_rx_cmp_to_index(struct bcm_op *op, int index,
- struct can_frame *rxdata);
-static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data);
-static void bcm_rx_starttimer(struct bcm_op *op);
-static void bcm_rx_update_and_send(struct bcm_op *op,
- struct can_frame *lastdata,
- struct can_frame *rxdata);
-static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,
- struct can_frame *frames, struct timeval *tv);
-
-static int bcm_delete_tx_op(struct list_head *ops, canid_t can_id,
- int ifindex);
-static int bcm_delete_rx_op(struct list_head *ops, canid_t can_id,
- int ifindex);
-static void bcm_remove_op(struct bcm_op *op);
-static int bcm_read_op(struct list_head *ops, struct bcm_msg_head *msg_head,
- int ifindex);
-static struct bcm_op *bcm_find_op(struct list_head *ops, canid_t can_id,
- int ifindex);
-
-static struct proto_ops bcm_ops = {
- .family = PF_CAN,
- .release = bcm_release,
- .bind = sock_no_bind,
- .connect = bcm_connect,
- .socketpair = sock_no_socketpair,
- .accept = sock_no_accept,
- .getname = sock_no_getname,
- .poll = bcm_poll,
- .ioctl = NULL, /* use can_ioctl() from af_can.c */
- .listen = sock_no_listen,
- .shutdown = sock_no_shutdown,
- .setsockopt = sock_no_setsockopt,
- .getsockopt = sock_no_getsockopt,
- .sendmsg = bcm_sendmsg,
- .recvmsg = bcm_recvmsg,
- .mmap = sock_no_mmap,
- .sendpage = sock_no_sendpage,
-};
-
-#ifdef CONFIG_CAN_BCM_USER
-#define BCM_CAP (-1)
-#else
-#define BCM_CAP CAP_NET_RAW
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
-struct bcm_sock {
- struct sock sk;
- struct bcm_opt opt;
-};
-
-#define bcm_sk(sk) (&((struct bcm_sock *)(sk))->opt)
-
-static struct proto bcm_proto = {
- .name = "CAN_BCM",
- .owner = THIS_MODULE,
- .obj_size = sizeof(struct bcm_sock),
- .init = bcm_init,
-};
-
-static struct can_proto bcm_can_proto = {
- .type = SOCK_DGRAM,
- .protocol = CAN_BCM,
- .capability = BCM_CAP,
- .ops = &bcm_ops,
- .prot = &bcm_proto,
-};
-#else
-#define bcm_sk(sk) ((struct bcm_opt *)(sk)->sk_protinfo)
-
-static struct can_proto bcm_can_proto = {
- .type = SOCK_DGRAM,
- .protocol = CAN_BCM,
- .capability = BCM_CAP,
- .ops = &bcm_ops,
- .owner = THIS_MODULE,
- .obj_size = sizeof(struct bcm_opt),
- .init = bcm_init,
+ char procname [32]; /* inode number in decimal with \0 */
};
-#endif
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)
-static void *kzalloc(size_t size, unsigned int __nocast flags)
-{
- void *ret = kmalloc(size, flags);
- if (ret)
- memset(ret, 0, size);
- return ret;
-}
-
-static inline void skb_get_timestamp(const struct sk_buff *skb,
- struct timeval *stamp)
-{
- stamp->tv_sec = skb->stamp.tv_sec;
- stamp->tv_usec = skb->stamp.tv_usec;
-}
-static inline void skb_set_timestamp(struct sk_buff *skb,
- const struct timeval *stamp)
+static inline struct bcm_sock *bcm_sk(const struct sock *sk)
{
- skb->stamp.tv_sec = stamp->tv_sec;
- skb->stamp.tv_usec = stamp->tv_usec;
+ return (struct bcm_sock *)sk;
}
-#endif
#define CFSIZ sizeof(struct can_frame)
#define OPSIZ sizeof(struct bcm_op)
#define MHSIZ sizeof(struct bcm_msg_head)
-static int __init bcm_module_init(void)
+/*
+ * procfs functions
+ */
+static char *bcm_proc_getifname(char *result, int ifindex)
{
- printk(banner);
-
- can_proto_register(&bcm_can_proto);
+ struct net_device *dev;
- /* create /proc/net/can/bcm directory */
- proc_dir = proc_mkdir(CAN_PROC_DIR"/"IDENT, NULL);
+ if (!ifindex)
+ return "any";
- if (proc_dir)
- proc_dir->owner = THIS_MODULE;
+ read_lock(&dev_base_lock);
+ dev = __dev_get_by_index(&init_net, ifindex);
+ if (dev)
+ strcpy(result, dev->name);
+ else
+ strcpy(result, "???");
+ read_unlock(&dev_base_lock);
- return 0;
+ return result;
}
-static void __exit bcm_module_exit(void)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+static int bcm_proc_show(struct seq_file *m, void *v)
{
- can_proto_unregister(&bcm_can_proto);
+ char ifname[IFNAMSIZ];
+ struct sock *sk = (struct sock *)m->private;
+ struct bcm_sock *bo = bcm_sk(sk);
+ struct bcm_op *op;
- if (proc_dir)
- remove_proc_entry(CAN_PROC_DIR"/"IDENT, NULL);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
+ seq_printf(m, ">>> socket %p", sk->sk_socket);
+ seq_printf(m, " / sk %p", sk);
+ seq_printf(m, " / bo %p", bo);
+#else
+ seq_printf(m, ">>> socket %pK", sk->sk_socket);
+ seq_printf(m, " / sk %pK", sk);
+ seq_printf(m, " / bo %pK", bo);
+#endif
+ seq_printf(m, " / dropped %lu", bo->dropped_usr_msgs);
+ seq_printf(m, " / bound %s", bcm_proc_getifname(ifname, bo->ifindex));
+ seq_printf(m, " <<<\n");
-}
+ list_for_each_entry(op, &bo->rx_ops, list) {
-/* initial settings at socket creation time */
+ unsigned long reduction;
-static int bcm_init(struct sock *sk)
-{
- struct bcm_opt *bo = bcm_sk(sk);
+ /* print only active entries & prevent division by zero */
+ if (!op->frames_abs)
+ continue;
- bo->bound = 0;
- bo->ifindex = 0;
- bo->dropped_usr_msgs = 0;
- bo->bcm_proc_read = NULL;
+ seq_printf(m, "rx_op: %03X %-5s ",
+ op->can_id, bcm_proc_getifname(ifname, op->ifindex));
+ seq_printf(m, "[%u]%c ", op->nframes,
+ (op->flags & RX_CHECK_DLC)?'d':' ');
+ if (op->kt_ival1.tv64)
+ seq_printf(m, "timeo=%lld ",
+ (long long)
+ ktime_to_us(op->kt_ival1));
- INIT_LIST_HEAD(&bo->tx_ops);
- INIT_LIST_HEAD(&bo->rx_ops);
+ if (op->kt_ival2.tv64)
+ seq_printf(m, "thr=%lld ",
+ (long long)
+ ktime_to_us(op->kt_ival2));
- return 0;
-}
+ seq_printf(m, "# recv %ld (%ld) => reduction: ",
+ op->frames_filtered, op->frames_abs);
-/* handling of netdevice problems */
+ reduction = 100 - (op->frames_filtered * 100) / op->frames_abs;
-static void bcm_notifier(unsigned long msg, void *data)
-{
- struct sock *sk = (struct sock *)data;
- struct bcm_opt *bo = bcm_sk(sk);
+ seq_printf(m, "%s%ld%%\n",
+ (reduction == 100)?"near ":"", reduction);
+ }
- DBG("called for sock %p\n", sk);
+ list_for_each_entry(op, &bo->tx_ops, list) {
- switch (msg) {
- case NETDEV_UNREGISTER:
- bo->bound = 0;
- bo->ifindex = 0;
- /* fallthrough */
- case NETDEV_DOWN:
- sk->sk_err = ENETDOWN;
- if (!sock_flag(sk, SOCK_DEAD))
- sk->sk_error_report(sk);
+ seq_printf(m, "tx_op: %03X %s [%u] ",
+ op->can_id,
+ bcm_proc_getifname(ifname, op->ifindex),
+ op->nframes);
+
+ if (op->kt_ival1.tv64)
+ seq_printf(m, "t1=%lld ",
+ (long long) ktime_to_us(op->kt_ival1));
+
+ if (op->kt_ival2.tv64)
+ seq_printf(m, "t2=%lld ",
+ (long long) ktime_to_us(op->kt_ival2));
+
+ seq_printf(m, "# sent %ld\n", op->frames_abs);
}
+ seq_putc(m, '\n');
+ return 0;
}
-/* standard socket functions */
+static int bcm_proc_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, bcm_proc_show, PDE(inode)->data);
+}
-static int bcm_release(struct socket *sock)
+static const struct file_operations bcm_proc_fops = {
+ .owner = THIS_MODULE,
+ .open = bcm_proc_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+#else
+static int bcm_read_proc(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
- struct sock *sk = sock->sk;
- struct bcm_opt *bo = bcm_sk(sk);
- struct bcm_op *op, *next;
+ char ifname[IFNAMSIZ];
+ int len = 0;
+ struct sock *sk = (struct sock *)data;
+ struct bcm_sock *bo = bcm_sk(sk);
+ struct bcm_op *op;
- DBG("socket %p, sk %p\n", sock, sk);
+ len += snprintf(page + len, PAGE_SIZE - len, ">>> socket %p",
+ sk->sk_socket);
+ len += snprintf(page + len, PAGE_SIZE - len, " / sk %p", sk);
+ len += snprintf(page + len, PAGE_SIZE - len, " / bo %p", bo);
+ len += snprintf(page + len, PAGE_SIZE - len, " / dropped %lu",
+ bo->dropped_usr_msgs);
+ len += snprintf(page + len, PAGE_SIZE - len, " / bound %s",
+ bcm_proc_getifname(ifname, bo->ifindex));
+ len += snprintf(page + len, PAGE_SIZE - len, " <<<\n");
- /* remove bcm_ops, timer, rx_unregister(), etc. */
+ list_for_each_entry(op, &bo->rx_ops, list) {
- list_for_each_entry_safe(op, next, &bo->tx_ops, list) {
- DBG("removing tx_op %p for can_id %03X\n", op, op->can_id);
- bcm_remove_op(op);
- }
+ unsigned long reduction;
- list_for_each_entry_safe(op, next, &bo->rx_ops, list) {
- DBG("removing rx_op %p for can_id %03X\n", op, op->can_id);
+ /* print only active entries & prevent division by zero */
+ if (!op->frames_abs)
+ continue;
- /*
- * Don't care if we're bound or not (due to netdev problems)
- * can_rx_unregister() is always a save thing to do here.
- */
- if (op->ifindex) {
- struct net_device *dev = dev_get_by_index(op->ifindex);
+ len += snprintf(page + len, PAGE_SIZE - len,
+ "rx_op: %03X %-5s ",
+ op->can_id, bcm_proc_getifname(ifname, op->ifindex));
+ len += snprintf(page + len, PAGE_SIZE - len, "[%d]%c ",
+ op->nframes,
+ (op->flags & RX_CHECK_DLC)?'d':' ');
+ if (op->kt_ival1.tv64)
+ len += snprintf(page + len, PAGE_SIZE - len,
+ "timeo=%lld ",
+ (long long)
+ ktime_to_us(op->kt_ival1));
- if (dev) {
- can_rx_unregister(dev, op->can_id,
- REGMASK(op->can_id),
- bcm_rx_handler, op);
- dev_put(dev);
- }
- } else
- can_rx_unregister(NULL, op->can_id,
- REGMASK(op->can_id),
- bcm_rx_handler, op);
+ if (op->kt_ival2.tv64)
+ len += snprintf(page + len, PAGE_SIZE - len,
+ "thr=%lld ",
+ (long long)
+ ktime_to_us(op->kt_ival2));
- bcm_remove_op(op);
- }
+ len += snprintf(page + len, PAGE_SIZE - len,
+ "# recv %ld (%ld) => reduction: ",
+ op->frames_filtered, op->frames_abs);
- /* remove procfs entry */
- if ((proc_dir) && (bo->bcm_proc_read)) {
- remove_proc_entry(bo->procname, proc_dir);
- }
+ reduction = 100 - (op->frames_filtered * 100) / op->frames_abs;
- /* remove device notifier */
- if (bo->ifindex) {
- struct net_device *dev = dev_get_by_index(bo->ifindex);
+ len += snprintf(page + len, PAGE_SIZE - len, "%s%ld%%\n",
+ (reduction == 100)?"near ":"", reduction);
- if (dev) {
- can_dev_unregister(dev, bcm_notifier, sk);
- dev_put(dev);
+ if (len > PAGE_SIZE - 200) {
+ /* mark output cut off */
+ len += snprintf(page + len, PAGE_SIZE - len, "(..)\n");
+ break;
}
}
- sock_put(sk);
+ list_for_each_entry(op, &bo->tx_ops, list) {
- return 0;
-}
+ len += snprintf(page + len, PAGE_SIZE - len,
+ "tx_op: %03X %s [%d] ",
+ op->can_id,
+ bcm_proc_getifname(ifname, op->ifindex),
+ op->nframes);
-static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len,
- int flags)
-{
- struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
- struct sock *sk = sock->sk;
- struct bcm_opt *bo = bcm_sk(sk);
+ if (op->kt_ival1.tv64)
+ len += snprintf(page + len, PAGE_SIZE - len, "t1=%lld ",
+ (long long) ktime_to_us(op->kt_ival1));
- if (bo->bound)
- return -EISCONN;
+ if (op->kt_ival2.tv64)
+ len += snprintf(page + len, PAGE_SIZE - len, "t2=%lld ",
+ (long long) ktime_to_us(op->kt_ival2));
- /* bind a device to this socket */
- if (addr->can_ifindex) {
- struct net_device *dev = dev_get_by_index(addr->can_ifindex);
+ len += snprintf(page + len, PAGE_SIZE - len, "# sent %ld\n",
+ op->frames_abs);
- if (!dev) {
- DBG("could not find device index %d\n",
- addr->can_ifindex);
- return -ENODEV;
+ if (len > PAGE_SIZE - 100) {
+ /* mark output cut off */
+ len += snprintf(page + len, PAGE_SIZE - len, "(..)\n");
+ break;
}
- bo->ifindex = dev->ifindex;
- can_dev_register(dev, bcm_notifier, sk); /* register notif. */
- dev_put(dev);
-
- DBG("socket %p bound to device %s (idx %d)\n",
- sock, dev->name, dev->ifindex);
- } else {
- /* no notifier for ifindex = 0 ('any' CAN device) */
- bo->ifindex = 0;
}
- bo->bound = 1;
-
- if (proc_dir) {
- /* unique socket address as filename */
- sprintf(bo->procname, "%p", sock);
- bo->bcm_proc_read = create_proc_read_entry(bo->procname, 0644,
- proc_dir,
- bcm_read_proc, sk);
- }
+ len += snprintf(page + len, PAGE_SIZE - len, "\n");
- return 0;
+ *eof = 1;
+ return len;
}
+#endif
-static int bcm_sendmsg(struct kiocb *iocb, struct socket *sock,
- struct msghdr *msg, size_t size)
+/*
+ * bcm_can_tx - send the (next) CAN frame to the appropriate CAN interface
+ * of the given bcm tx op
+ */
+static void bcm_can_tx(struct bcm_op *op)
{
- struct sock *sk = sock->sk;
- struct bcm_opt *bo = bcm_sk(sk);
- int ifindex = bo->ifindex; /* default ifindex for this bcm_op */
- struct bcm_msg_head msg_head;
- int ret; /* read bytes or error codes as return value */
+ struct sk_buff *skb;
+ struct net_device *dev;
+ struct can_frame *cf = &op->frames[op->currframe];
- if (!bo->bound) {
- DBG("sock %p not bound\n", sk);
- return -ENOTCONN;
+ /* no target device? => exit */
+ if (!op->ifindex)
+ return;
+
+ dev = dev_get_by_index(&init_net, op->ifindex);
+ if (!dev) {
+ /* RFC: should this bcm_op remove itself here? */
+ return;
}
- /* check for alternative ifindex for this bcm_op */
+ skb = alloc_skb(CFSIZ, gfp_any());
+ if (!skb)
+ goto out;
- if (!ifindex && msg->msg_name) {
- /* no bound device as default => check msg_name */
- struct sockaddr_can *addr =
- (struct sockaddr_can *)msg->msg_name;
+ memcpy(skb_put(skb, CFSIZ), cf, CFSIZ);
- if (addr->can_family != AF_CAN)
- return -EINVAL;
+ /* send with loopback */
+ skb->dev = dev;
+ skb->sk = op->sk;
+ can_send(skb, 1);
- ifindex = addr->can_ifindex; /* ifindex from sendto() */
+ /* update statistics */
+ op->currframe++;
+ op->frames_abs++;
- if (ifindex && !dev_get_by_index(ifindex)) {
- DBG("device %d not found\n", ifindex);
- return -ENODEV;
+ /* reached last frame? */
+ if (op->currframe >= op->nframes)
+ op->currframe = 0;
+ out:
+ dev_put(dev);
+}
+
+/*
+ * bcm_send_to_user - send a BCM message to the userspace
+ * (consisting of bcm_msg_head + x CAN frames)
+ */
+static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,
+ struct can_frame *frames, int has_timestamp)
+{
+ struct sk_buff *skb;
+ struct can_frame *firstframe;
+ struct sockaddr_can *addr;
+ struct sock *sk = op->sk;
+ unsigned int datalen = head->nframes * CFSIZ;
+ int err;
+
+ skb = alloc_skb(sizeof(*head) + datalen, gfp_any());
+ if (!skb)
+ return;
+
+ memcpy(skb_put(skb, sizeof(*head)), head, sizeof(*head));
+
+ if (head->nframes) {
+ /* can_frames starting here */
+ firstframe = (struct can_frame *)skb_tail_pointer(skb);
+
+ memcpy(skb_put(skb, datalen), frames, datalen);
+
+ /*
+ * the BCM uses the can_dlc-element of the can_frame
+ * structure for internal purposes. This is only
+ * relevant for updates that are generated by the
+ * BCM, where nframes is 1
+ */
+ if (head->nframes == 1)
+ firstframe->can_dlc &= BCM_CAN_DLC_MASK;
+ }
+
+ if (has_timestamp) {
+ /* restore rx timestamp */
+ skb->tstamp = op->rx_stamp;
+ }
+
+ /*
+ * Put the datagram to the queue so that bcm_recvmsg() can
+ * get it from there. We need to pass the interface index to
+ * bcm_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
+ * containing the interface index.
+ */
+
+ BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
+ addr = (struct sockaddr_can *)skb->cb;
+ memset(addr, 0, sizeof(*addr));
+ addr->can_family = AF_CAN;
+ addr->can_ifindex = op->rx_ifindex;
+
+ err = sock_queue_rcv_skb(sk, skb);
+ if (err < 0) {
+ struct bcm_sock *bo = bcm_sk(sk);
+
+ kfree_skb(skb);
+ /* don't care about overflows in this statistic */
+ bo->dropped_usr_msgs++;
+ }
+}
+
+static void bcm_tx_start_timer(struct bcm_op *op)
+{
+ if (op->kt_ival1.tv64 && op->count)
+ hrtimer_start(&op->timer,
+ ktime_add(ktime_get(), op->kt_ival1),
+ HRTIMER_MODE_ABS);
+ else if (op->kt_ival2.tv64)
+ hrtimer_start(&op->timer,
+ ktime_add(ktime_get(), op->kt_ival2),
+ HRTIMER_MODE_ABS);
+}
+
+static void bcm_tx_timeout_tsklet(unsigned long data)
+{
+ struct bcm_op *op = (struct bcm_op *)data;
+ struct bcm_msg_head msg_head;
+
+ if (op->kt_ival1.tv64 && (op->count > 0)) {
+
+ op->count--;
+ if (!op->count && (op->flags & TX_COUNTEVT)) {
+
+ /* create notification to user */
+ msg_head.opcode = TX_EXPIRED;
+ msg_head.flags = op->flags;
+ msg_head.count = op->count;
+ msg_head.ival1 = op->ival1;
+ msg_head.ival2 = op->ival2;
+ msg_head.can_id = op->can_id;
+ msg_head.nframes = 0;
+
+ bcm_send_to_user(op, &msg_head, NULL, 0);
}
+ bcm_can_tx(op);
+
+ } else if (op->kt_ival2.tv64)
+ bcm_can_tx(op);
+
+ bcm_tx_start_timer(op);
+}
+
+/*
+ * bcm_tx_timeout_handler - performs cyclic CAN frame transmissions
+ */
+static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer)
+{
+ struct bcm_op *op = container_of(hrtimer, struct bcm_op, timer);
+
+ tasklet_schedule(&op->tsklet);
+
+ return HRTIMER_NORESTART;
+}
+
+/*
+ * bcm_rx_changed - create a RX_CHANGED notification due to changed content
+ */
+static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data)
+{
+ struct bcm_msg_head head;
+
+ /* update statistics */
+ op->frames_filtered++;
+
+ /* prevent statistics overflow */
+ if (op->frames_filtered > ULONG_MAX/100)
+ op->frames_filtered = op->frames_abs = 0;
+
+ /* this element is not throttled anymore */
+ data->can_dlc &= (BCM_CAN_DLC_MASK|RX_RECV);
+
+ head.opcode = RX_CHANGED;
+ head.flags = op->flags;
+ head.count = op->count;
+ head.ival1 = op->ival1;
+ head.ival2 = op->ival2;
+ head.can_id = op->can_id;
+ head.nframes = 1;
+
+ bcm_send_to_user(op, &head, data, 1);
+}
+
+#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,25)
+/* is part of linux/hrtimer.h since 2.6.26 */
+static inline int hrtimer_callback_running(struct hrtimer *timer)
+{
+ return timer->state & HRTIMER_STATE_CALLBACK;
+}
+#endif
+#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,22)
+static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
+{
+ return ktime_to_us(ktime_sub(later, earlier));
+}
+#endif
+/*
+ * bcm_rx_update_and_send - process a detected relevant receive content change
+ * 1. update the last received data
+ * 2. send a notification to the user (if possible)
+ */
+static void bcm_rx_update_and_send(struct bcm_op *op,
+ struct can_frame *lastdata,
+ const struct can_frame *rxdata)
+{
+ memcpy(lastdata, rxdata, CFSIZ);
+
+ /* mark as used and throttled by default */
+ lastdata->can_dlc |= (RX_RECV|RX_THR);
+
+ /* throtteling mode inactive ? */
+ if (!op->kt_ival2.tv64) {
+ /* send RX_CHANGED to the user immediately */
+ bcm_rx_changed(op, lastdata);
+ return;
}
- /* read message head information */
+ /* with active throttling timer we are just done here */
+ if (hrtimer_active(&op->thrtimer))
+ return;
- ret = memcpy_fromiovec((u8*)&msg_head, msg->msg_iov, MHSIZ);
- if (ret < 0)
- return ret;
+ /* first receiption with enabled throttling mode */
+ if (!op->kt_lastmsg.tv64)
+ goto rx_changed_settime;
+
+ /* got a second frame inside a potential throttle period? */
+ if (ktime_us_delta(ktime_get(), op->kt_lastmsg) <
+ ktime_to_us(op->kt_ival2)) {
+ /* do not send the saved data - only start throttle timer */
+ hrtimer_start(&op->thrtimer,
+ ktime_add(op->kt_lastmsg, op->kt_ival2),
+ HRTIMER_MODE_ABS);
+ return;
+ }
- DBG("opcode %d for can_id %03X\n", msg_head.opcode, msg_head.can_id);
+ /* the gap was that big, that throttling was not needed here */
+rx_changed_settime:
+ bcm_rx_changed(op, lastdata);
+ op->kt_lastmsg = ktime_get();
+}
- switch (msg_head.opcode) {
+/*
+ * bcm_rx_cmp_to_index - (bit)compares the currently received data to formerly
+ * received data stored in op->last_frames[]
+ */
+static void bcm_rx_cmp_to_index(struct bcm_op *op, unsigned int index,
+ const struct can_frame *rxdata)
+{
+ /*
+ * no one uses the MSBs of can_dlc for comparation,
+ * so we use it here to detect the first time of reception
+ */
- case TX_SETUP:
+ if (!(op->last_frames[index].can_dlc & RX_RECV)) {
+ /* received data for the first time => send update to user */
+ bcm_rx_update_and_send(op, &op->last_frames[index], rxdata);
+ return;
+ }
- ret = bcm_tx_setup(&msg_head, msg, ifindex, sk);
- break;
+ /* do a real check in can_frame data section */
- case RX_SETUP:
+ if ((GET_U64(&op->frames[index]) & GET_U64(rxdata)) !=
+ (GET_U64(&op->frames[index]) & GET_U64(&op->last_frames[index]))) {
+ bcm_rx_update_and_send(op, &op->last_frames[index], rxdata);
+ return;
+ }
- ret = bcm_rx_setup(&msg_head, msg, ifindex, sk);
- break;
+ if (op->flags & RX_CHECK_DLC) {
+ /* do a real check in can_frame dlc */
+ if (rxdata->can_dlc != (op->last_frames[index].can_dlc &
+ BCM_CAN_DLC_MASK)) {
+ bcm_rx_update_and_send(op, &op->last_frames[index],
+ rxdata);
+ return;
+ }
+ }
+}
- case TX_DELETE:
+/*
+ * bcm_rx_starttimer - enable timeout monitoring for CAN frame receiption
+ */
+static void bcm_rx_starttimer(struct bcm_op *op)
+{
+ if (op->flags & RX_NO_AUTOTIMER)
+ return;
- if (bcm_delete_tx_op(&bo->tx_ops, msg_head.can_id, ifindex))
- ret = MHSIZ;
- else
- ret = -EINVAL;
- break;
-
- case RX_DELETE:
+ if (op->kt_ival1.tv64)
+ hrtimer_start(&op->timer, op->kt_ival1, HRTIMER_MODE_REL);
+}
- if (bcm_delete_rx_op(&bo->rx_ops, msg_head.can_id, ifindex))
- ret = MHSIZ;
- else
- ret = -EINVAL;
- break;
+static void bcm_rx_timeout_tsklet(unsigned long data)
+{
+ struct bcm_op *op = (struct bcm_op *)data;
+ struct bcm_msg_head msg_head;
- case TX_READ:
+ /* create notification to user */
+ msg_head.opcode = RX_TIMEOUT;
+ msg_head.flags = op->flags;
+ msg_head.count = op->count;
+ msg_head.ival1 = op->ival1;
+ msg_head.ival2 = op->ival2;
+ msg_head.can_id = op->can_id;
+ msg_head.nframes = 0;
- /* reuse msg_head for the reply to TX_READ */
- msg_head.opcode = TX_STATUS;
- ret = bcm_read_op(&bo->tx_ops, &msg_head, ifindex);
- break;
+ bcm_send_to_user(op, &msg_head, NULL, 0);
+}
- case RX_READ:
+/*
+ * bcm_rx_timeout_handler - when the (cyclic) CAN frame receiption timed out
+ */
+static enum hrtimer_restart bcm_rx_timeout_handler(struct hrtimer *hrtimer)
+{
+ struct bcm_op *op = container_of(hrtimer, struct bcm_op, timer);
- /* reuse msg_head for the reply to RX_READ */
- msg_head.opcode = RX_STATUS;
- ret = bcm_read_op(&bo->rx_ops, &msg_head, ifindex);
- break;
+ /* schedule before NET_RX_SOFTIRQ */
+ tasklet_hi_schedule(&op->tsklet);
- case TX_SEND:
+ /* no restart of the timer is done here! */
- /* we need at least one can_frame */
- if (msg_head.nframes < 1)
- return -EINVAL;
+ /* if user wants to be informed, when cyclic CAN-Messages come back */
+ if ((op->flags & RX_ANNOUNCE_RESUME) && op->last_frames) {
+ /* clear received can_frames to indicate 'nothing received' */
+ memset(op->last_frames, 0, op->nframes * CFSIZ);
+ }
- ret = bcm_tx_send(msg, ifindex, sk);
- break;
+ return HRTIMER_NORESTART;
+}
- default:
+/*
+ * bcm_rx_do_flush - helper for bcm_rx_thr_flush
+ */
+static inline int bcm_rx_do_flush(struct bcm_op *op, int update,
+ unsigned int index)
+{
+ if ((op->last_frames) && (op->last_frames[index].can_dlc & RX_THR)) {
+ if (update)
+ bcm_rx_changed(op, &op->last_frames[index]);
+ return 1;
+ }
+ return 0;
+}
- DBG("Unknown opcode %d\n", msg_head.opcode);
- ret = -EINVAL;
- break;
+/*
+ * bcm_rx_thr_flush - Check for throttled data and send it to the userspace
+ *
+ * update == 0 : just check if throttled data is available (any irq context)
+ * update == 1 : check and send throttled data to userspace (soft_irq context)
+ */
+static int bcm_rx_thr_flush(struct bcm_op *op, int update)
+{
+ int updated = 0;
+
+ if (op->nframes > 1) {
+ unsigned int i;
+
+ /* for MUX filter we start at index 1 */
+ for (i = 1; i < op->nframes; i++)
+ updated += bcm_rx_do_flush(op, update, i);
+
+ } else {
+ /* for RX_FILTER_ID and simple filter */
+ updated += bcm_rx_do_flush(op, update, 0);
}
- return ret;
+ return updated;
}
-static int bcm_recvmsg(struct kiocb *iocb, struct socket *sock,
- struct msghdr *msg, size_t size, int flags)
+static void bcm_rx_thr_tsklet(unsigned long data)
{
- struct sock *sk = sock->sk;
- struct sk_buff *skb;
- int error = 0;
- int noblock;
- int err;
+ struct bcm_op *op = (struct bcm_op *)data;
- DBG("socket %p, sk %p\n", sock, sk);
+ /* push the changed data to the userspace */
+ bcm_rx_thr_flush(op, 1);
+}
- noblock = flags & MSG_DONTWAIT;
- flags &= ~MSG_DONTWAIT;
- skb = skb_recv_datagram(sk, flags, noblock, &error);
- if (!skb)
- return error;
+/*
+ * bcm_rx_thr_handler - the time for blocked content updates is over now:
+ * Check for throttled data and send it to the userspace
+ */
+static enum hrtimer_restart bcm_rx_thr_handler(struct hrtimer *hrtimer)
+{
+ struct bcm_op *op = container_of(hrtimer, struct bcm_op, thrtimer);
- DBG("delivering skbuff %p\n", skb);
- DBG_SKB(skb);
+ tasklet_schedule(&op->thrtsklet);
- if (skb->len < size)
- size = skb->len;
+ if (bcm_rx_thr_flush(op, 0)) {
+ hrtimer_forward(hrtimer, ktime_get(), op->kt_ival2);
+ return HRTIMER_RESTART;
+ } else {
+ /* rearm throttle handling */
+ op->kt_lastmsg = ktime_set(0, 0);
+ return HRTIMER_NORESTART;
+ }
+}
- err = memcpy_toiovec(msg->msg_iov, skb->data, size);
- if (err < 0) {
- skb_free_datagram(sk, skb);
- return err;
+/*
+ * bcm_rx_handler - handle a CAN frame receiption
+ */
+static void bcm_rx_handler(struct sk_buff *skb, void *data)
+{
+ struct bcm_op *op = (struct bcm_op *)data;
+ const struct can_frame *rxframe = (struct can_frame *)skb->data;
+ unsigned int i;
+
+ /* disable timeout */
+ hrtimer_cancel(&op->timer);
+
+ if (op->can_id != rxframe->can_id)
+ return;
+
+ /* save rx timestamp */
+ op->rx_stamp = skb->tstamp;
+ /* save originator for recvfrom() */
+ op->rx_ifindex = skb->dev->ifindex;
+ /* update statistics */
+ op->frames_abs++;
+
+ if (op->flags & RX_RTR_FRAME) {
+ /* send reply for RTR-request (placed in op->frames[0]) */
+ bcm_can_tx(op);
+ return;
}
- sock_recv_timestamp(msg, sk, skb);
+ if (op->flags & RX_FILTER_ID) {
+ /* the easiest case */
+ bcm_rx_update_and_send(op, &op->last_frames[0], rxframe);
+ goto rx_starttimer;
+ }
- if (msg->msg_name) {
- msg->msg_namelen = sizeof(struct sockaddr_can);
- memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
+ if (op->nframes == 1) {
+ /* simple compare with index 0 */
+ bcm_rx_cmp_to_index(op, 0, rxframe);
+ goto rx_starttimer;
}
- DBG("freeing sock %p, skbuff %p\n", sk, skb);
- skb_free_datagram(sk, skb);
+ if (op->nframes > 1) {
+ /*
+ * multiplex compare
+ *
+ * find the first multiplex mask that fits.
+ * Remark: The MUX-mask is stored in index 0
+ */
- return size;
+ for (i = 1; i < op->nframes; i++) {
+ if ((GET_U64(&op->frames[0]) & GET_U64(rxframe)) ==
+ (GET_U64(&op->frames[0]) &
+ GET_U64(&op->frames[i]))) {
+ bcm_rx_cmp_to_index(op, i, rxframe);
+ break;
+ }
+ }
+ }
+
+rx_starttimer:
+ bcm_rx_starttimer(op);
+}
+
+/*
+ * helpers for bcm_op handling: find & delete bcm [rx|tx] op elements
+ */
+static struct bcm_op *bcm_find_op(struct list_head *ops, canid_t can_id,
+ int ifindex)
+{
+ struct bcm_op *op;
+
+ list_for_each_entry(op, ops, list) {
+ if ((op->can_id == can_id) && (op->ifindex == ifindex))
+ return op;
+ }
+
+ return NULL;
}
-static unsigned int bcm_poll(struct file *file, struct socket *sock,
- poll_table *wait)
+static void bcm_remove_op(struct bcm_op *op)
{
- unsigned int mask = 0;
+ hrtimer_cancel(&op->timer);
+ hrtimer_cancel(&op->thrtimer);
+
+ if (op->tsklet.func)
+ tasklet_kill(&op->tsklet);
+
+ if (op->thrtsklet.func)
+ tasklet_kill(&op->thrtsklet);
+
+ if ((op->frames) && (op->frames != &op->sframe))
+ kfree(op->frames);
+
+ if ((op->last_frames) && (op->last_frames != &op->last_sframe))
+ kfree(op->last_frames);
+
+ kfree(op);
- DBG("socket %p\n", sock);
+ return;
+}
- mask = datagram_poll(file, sock, wait);
- return mask;
+static void bcm_rx_unreg(struct net_device *dev, struct bcm_op *op)
+{
+ if (op->rx_reg_dev == dev) {
+ can_rx_unregister(dev, op->can_id, REGMASK(op->can_id),
+ bcm_rx_handler, op);
+
+ /* mark as removed subscription */
+ op->rx_reg_dev = NULL;
+ } else
+ printk(KERN_ERR "can-bcm: bcm_rx_unreg: registered device "
+ "mismatch %p %p\n", op->rx_reg_dev, dev);
}
-/* helper functions for bcm_sendmsg() */
+/*
+ * bcm_delete_rx_op - find and remove a rx op (returns number of removed ops)
+ */
+static int bcm_delete_rx_op(struct list_head *ops, canid_t can_id, int ifindex)
+{
+ struct bcm_op *op, *n;
+
+ list_for_each_entry_safe(op, n, ops, list) {
+ if ((op->can_id == can_id) && (op->ifindex == ifindex)) {
+
+ /*
+ * Don't care if we're bound or not (due to netdev
+ * problems) can_rx_unregister() is always a save
+ * thing to do here.
+ */
+ if (op->ifindex) {
+ /*
+ * Only remove subscriptions that had not
+ * been removed due to NETDEV_UNREGISTER
+ * in bcm_notifier()
+ */
+ if (op->rx_reg_dev) {
+ struct net_device *dev;
+
+ dev = dev_get_by_index(&init_net,
+ op->ifindex);
+ if (dev) {
+ bcm_rx_unreg(dev, op);
+ dev_put(dev);
+ }
+ }
+ } else
+ can_rx_unregister(NULL, op->can_id,
+ REGMASK(op->can_id),
+ bcm_rx_handler, op);
+ list_del(&op->list);
+ bcm_remove_op(op);
+ return 1; /* done */
+ }
+ }
+
+ return 0; /* not found */
+}
+
+/*
+ * bcm_delete_tx_op - find and remove a tx op (returns number of removed ops)
+ */
+static int bcm_delete_tx_op(struct list_head *ops, canid_t can_id, int ifindex)
+{
+ struct bcm_op *op, *n;
+
+ list_for_each_entry_safe(op, n, ops, list) {
+ if ((op->can_id == can_id) && (op->ifindex == ifindex)) {
+ list_del(&op->list);
+ bcm_remove_op(op);
+ return 1; /* done */
+ }
+ }
+
+ return 0; /* not found */
+}
+
+/*
+ * bcm_read_op - read out a bcm_op and send it to the user (for bcm_sendmsg)
+ */
+static int bcm_read_op(struct list_head *ops, struct bcm_msg_head *msg_head,
+ int ifindex)
+{
+ struct bcm_op *op = bcm_find_op(ops, msg_head->can_id, ifindex);
+
+ if (!op)
+ return -EINVAL;
+
+ /* put current values into msg_head */
+ msg_head->flags = op->flags;
+ msg_head->count = op->count;
+ msg_head->ival1 = op->ival1;
+ msg_head->ival2 = op->ival2;
+ msg_head->nframes = op->nframes;
+
+ bcm_send_to_user(op, msg_head, op->frames, 0);
+
+ return MHSIZ;
+}
+
+/*
+ * bcm_tx_setup - create or update a bcm tx op (for bcm_sendmsg)
+ */
static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
int ifindex, struct sock *sk)
{
- struct bcm_opt *bo = bcm_sk(sk);
+ struct bcm_sock *bo = bcm_sk(sk);
struct bcm_op *op;
- int i, err;
+ unsigned int i;
+ int err;
/* we need a real device to send frames */
if (!ifindex)
return -ENODEV;
- /* we need at least one can_frame */
- if (msg_head->nframes < 1)
+ /* check nframes boundaries - we need at least one can_frame */
+ if (msg_head->nframes < 1 || msg_head->nframes > MAX_NFRAMES)
return -EINVAL;
/* check the given can_id */
-
op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex);
- if (op) {
+ if (op) {
/* update existing BCM operation */
- DBG("TX_SETUP: modifying existing tx_op %p for can_id %03X\n",
- op, msg_head->can_id);
-
/*
* Do we need more space for the can_frames than currently
* allocated? -> This is a _really_ unusual use-case and
/* update can_frames content */
for (i = 0; i < msg_head->nframes; i++) {
- err = memcpy_fromiovec((u8*)&op->frames[i],
+ err = memcpy_fromiovec((u8 *)&op->frames[i],
msg->msg_iov, CFSIZ);
+
+ if (op->frames[i].can_dlc > 8)
+ err = -EINVAL;
+
if (err < 0)
return err;
if (!op)
return -ENOMEM;
- DBG("TX_SETUP: creating new tx_op %p for can_id %03X\n",
- op, msg_head->can_id);
-
op->can_id = msg_head->can_id;
/* create array for can_frames and copy the data */
- op->frames = kmalloc(msg_head->nframes * CFSIZ, GFP_KERNEL);
- if (!op->frames) {
- kfree(op);
- return -ENOMEM;
- }
+ if (msg_head->nframes > 1) {
+ op->frames = kmalloc(msg_head->nframes * CFSIZ,
+ GFP_KERNEL);
+ if (!op->frames) {
+ kfree(op);
+ return -ENOMEM;
+ }
+ } else
+ op->frames = &op->sframe;
for (i = 0; i < msg_head->nframes; i++) {
- err = memcpy_fromiovec((u8*)&op->frames[i],
+ err = memcpy_fromiovec((u8 *)&op->frames[i],
msg->msg_iov, CFSIZ);
+
+ if (op->frames[i].can_dlc > 8)
+ err = -EINVAL;
+
if (err < 0) {
- kfree(op->frames);
+ if (op->frames != &op->sframe)
+ kfree(op->frames);
kfree(op);
return err;
}
/* bcm_can_tx / bcm_tx_timeout_handler needs this */
op->sk = sk;
-
op->ifindex = ifindex;
- /* initialize uninitialized (kmalloc) structure */
- init_timer(&op->timer);
-
- /* currently unused in tx_ops */
- init_timer(&op->thrtimer);
-
- /* handler for tx_ops */
+ /* initialize uninitialized (kzalloc) structure */
+ hrtimer_init(&op->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
op->timer.function = bcm_tx_timeout_handler;
- /* timer.data points to this op-structure */
- op->timer.data = (unsigned long)op;
+ /* initialize tasklet for tx countevent notification */
+ tasklet_init(&op->tsklet, bcm_tx_timeout_tsklet,
+ (unsigned long) op);
+
+ /* currently unused in tx_ops */
+ hrtimer_init(&op->thrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
/* add this bcm_op to the list of the tx_ops */
list_add(&op->list, &bo->tx_ops);
if (op->flags & TX_RESET_MULTI_IDX) {
/* start multiple frame transmission with index 0 */
- op->currframe = 0;
+ op->currframe = 0;
}
if (op->flags & SETTIMER) {
-
/* set timer values */
-
op->count = msg_head->count;
op->ival1 = msg_head->ival1;
op->ival2 = msg_head->ival2;
- op->j_ival1 = timeval2jiffies(&msg_head->ival1, 1);
- op->j_ival2 = timeval2jiffies(&msg_head->ival2, 1);
-
- DBG("TX_SETUP: SETTIMER count=%d j_ival1=%ld j_ival2=%ld\n",
- op->count, op->j_ival1, op->j_ival2);
+ op->kt_ival1 = timeval_to_ktime(msg_head->ival1);
+ op->kt_ival2 = timeval_to_ktime(msg_head->ival2);
/* disable an active timer due to zero values? */
- if (!op->j_ival1 && !op->j_ival2) {
- del_timer(&op->timer);
- DBG("TX_SETUP: SETTIMER disabled timer.\n");
- }
+ if (!op->kt_ival1.tv64 && !op->kt_ival2.tv64)
+ hrtimer_cancel(&op->timer);
}
- if ((op->flags & STARTTIMER) &&
- ((op->j_ival1 && op->count) || op->j_ival2)) {
-
- del_timer(&op->timer);
-
+ if (op->flags & STARTTIMER) {
+ hrtimer_cancel(&op->timer);
/* spec: send can_frame when starting timer */
op->flags |= TX_ANNOUNCE;
-
- if (op->j_ival1 && (op->count > 0)){
- op->timer.expires = jiffies + op->j_ival1;
- /* op->count-- is done in bcm_tx_timeout_handler */
- DBG("TX_SETUP: adding timer ival1. func=%p data=%p "
- "exp=0x%08X\n",
- op->timer.function,
- (char*) op->timer.data,
- (unsigned int) op->timer.expires);
- } else{
- op->timer.expires = jiffies + op->j_ival2;
- DBG("TX_SETUP: adding timer ival2. func=%p data=%p "
- "exp=0x%08X\n",
- op->timer.function,
- (char*) op->timer.data,
- (unsigned int) op->timer.expires);
- }
-
- add_timer(&op->timer);
}
- if (op->flags & TX_ANNOUNCE)
+ if (op->flags & TX_ANNOUNCE) {
bcm_can_tx(op);
+ if (op->count)
+ op->count--;
+ }
+
+ if (op->flags & STARTTIMER)
+ bcm_tx_start_timer(op);
return msg_head->nframes * CFSIZ + MHSIZ;
}
+/*
+ * bcm_rx_setup - create or update a bcm rx op (for bcm_sendmsg)
+ */
static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
int ifindex, struct sock *sk)
{
- struct bcm_opt *bo = bcm_sk(sk);
+ struct bcm_sock *bo = bcm_sk(sk);
struct bcm_op *op;
int do_rx_register;
- int err;
+ int err = 0;
if ((msg_head->flags & RX_FILTER_ID) || (!(msg_head->nframes))) {
/* be robust against wrong usage ... */
msg_head->flags |= RX_FILTER_ID;
- msg_head->nframes = 0; /* ignore trailing garbage */
+ /* ignore trailing garbage */
+ msg_head->nframes = 0;
}
+ /* the first element contains the mux-mask => MAX_NFRAMES + 1 */
+ if (msg_head->nframes > MAX_NFRAMES + 1)
+ return -EINVAL;
+
if ((msg_head->flags & RX_RTR_FRAME) &&
((msg_head->nframes != 1) ||
- (!(msg_head->can_id & CAN_RTR_FLAG)))) {
-
- DBG("RX_SETUP: bad RX_RTR_FRAME setup!\n");
+ (!(msg_head->can_id & CAN_RTR_FLAG))))
return -EINVAL;
- }
/* check the given can_id */
op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex);
if (op) {
-
/* update existing BCM operation */
- DBG("RX_SETUP: modifying existing rx_op %p for can_id %03X\n",
- op, msg_head->can_id);
-
/*
* Do we need more space for the can_frames than currently
* allocated? -> This is a _really_ unusual use-case and
if (msg_head->nframes) {
/* update can_frames content */
- err = memcpy_fromiovec((u8*)op->frames,
+ err = memcpy_fromiovec((u8 *)op->frames,
msg->msg_iov,
msg_head->nframes * CFSIZ);
if (err < 0)
}
op->nframes = msg_head->nframes;
+
/* Only an update -> do not call can_rx_register() */
do_rx_register = 0;
} else {
/* insert new BCM operation for the given can_id */
-
op = kzalloc(OPSIZ, GFP_KERNEL);
if (!op)
return -ENOMEM;
- DBG("RX_SETUP: creating new rx_op %p for can_id %03X\n",
- op, msg_head->can_id);
-
op->can_id = msg_head->can_id;
op->nframes = msg_head->nframes;
- if (msg_head->nframes) {
-
+ if (msg_head->nframes > 1) {
/* create array for can_frames and copy the data */
op->frames = kmalloc(msg_head->nframes * CFSIZ,
GFP_KERNEL);
return -ENOMEM;
}
- err = memcpy_fromiovec((u8*)op->frames, msg->msg_iov,
- msg_head->nframes * CFSIZ);
- if (err < 0) {
- kfree(op->frames);
- kfree(op);
- return err;
- }
-
/* create and init array for received can_frames */
op->last_frames = kzalloc(msg_head->nframes * CFSIZ,
GFP_KERNEL);
kfree(op);
return -ENOMEM;
}
- } else {
- /* op->frames = NULL due to memset in kzalloc() */
-
- /*
- * even when we have the RX_FILTER_ID case, we need
- * to store the last frame for the throttle feature
- */
-
- /* create and init array for received can_frames */
- op->last_frames = kzalloc(CFSIZ, GFP_KERNEL);
- if (!op->last_frames) {
- kfree(op);
- return -ENOMEM;
- }
- }
-
- op->sk = sk; /* bcm_delete_rx_op() needs this */
- op->ifindex = ifindex;
-
- /* initialize uninitialized (kmalloc) structure */
- init_timer(&op->timer);
-
- /* init throttle timer for RX_CHANGED */
- init_timer(&op->thrtimer);
-
- /* handler for rx timeouts */
- op->timer.function = bcm_rx_timeout_handler;
-
- /* timer.data points to this op-structure */
- op->timer.data = (unsigned long)op;
-
- /* handler for RX_CHANGED throttle timeouts */
- op->thrtimer.function = bcm_rx_thr_handler;
-
- /* timer.data points to this op-structure */
- op->thrtimer.data = (unsigned long)op;
-
- op->thrtimer.expires = 0; /* mark disabled timer */
-
- /* add this bcm_op to the list of the tx_ops */
- list_add(&op->list, &bo->rx_ops);
-
- do_rx_register = 1; /* call can_rx_register() */
-
- } /* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */
-
-
- /* check flags */
-
- op->flags = msg_head->flags;
-
- if (op->flags & RX_RTR_FRAME) {
-
- /* no timers in RTR-mode */
- del_timer(&op->thrtimer);
- del_timer(&op->timer);
-
- /*
- * funny feature in RX(!)_SETUP only for RTR-mode:
- * copy can_id into frame BUT without RTR-flag to
- * prevent a full-load-loopback-test ... ;-]
- */
- if ((op->flags & TX_CP_CAN_ID) ||
- (op->frames[0].can_id == op->can_id))
- op->frames[0].can_id = op->can_id & ~CAN_RTR_FLAG;
-
- } else {
- if (op->flags & SETTIMER) {
-
- /* set timer value */
-
- op->ival1 = msg_head->ival1;
- op->ival2 = msg_head->ival2;
- op->j_ival1 = timeval2jiffies(&msg_head->ival1, 1);
- op->j_ival2 = timeval2jiffies(&msg_head->ival2, 1);
-
- DBG("RX_SETUP: SETTIMER j_ival1=%ld j_ival2=%ld\n",
- op->j_ival1, op->j_ival2);
-
- /* disable an active timer due to zero value? */
- if (!op->j_ival1) {
- del_timer(&op->timer);
- DBG("RX_SETUP: disabled timer rx timeouts.\n");
- }
-
- /* free currently blocked msgs ? */
- if (op->thrtimer.expires) {
- DBG("RX_SETUP: unblocking throttled msgs.\n");
- del_timer(&op->thrtimer);
- /* send blocked msgs hereafter */
- op->thrtimer.expires = jiffies + 2;
- add_timer(&op->thrtimer);
- }
- /*
- * if (op->j_ival2) is zero, no (new) throttling
- * will happen. For details see functions
- * bcm_rx_update_and_send() and bcm_rx_thr_handler()
- */
- }
-
- if ((op->flags & STARTTIMER) && op->j_ival1) {
-
- del_timer(&op->timer);
-
- op->timer.expires = jiffies + op->j_ival1;
-
- DBG("RX_SETUP: adding timer ival1. func=%p data=%p"
- " exp=0x%08X\n",
- (char *) op->timer.function,
- (char *) op->timer.data,
- (unsigned int) op->timer.expires);
- add_timer(&op->timer);
+ } else {
+ op->frames = &op->sframe;
+ op->last_frames = &op->last_sframe;
}
- }
-
- /* now we can register for can_ids, if we added a new bcm_op */
- if (do_rx_register) {
- DBG("RX_SETUP: can_rx_register() for can_id %03X. "
- "rx_op is %p\n", op->can_id, op);
-
- if (ifindex) {
- struct net_device *dev = dev_get_by_index(ifindex);
- if (dev) {
- can_rx_register(dev, op->can_id,
- REGMASK(op->can_id),
- bcm_rx_handler, op, IDENT);
- dev_put(dev);
+ if (msg_head->nframes) {
+ err = memcpy_fromiovec((u8 *)op->frames, msg->msg_iov,
+ msg_head->nframes * CFSIZ);
+ if (err < 0) {
+ if (op->frames != &op->sframe)
+ kfree(op->frames);
+ if (op->last_frames != &op->last_sframe)
+ kfree(op->last_frames);
+ kfree(op);
+ return err;
}
- } else
- can_rx_register(NULL, op->can_id, REGMASK(op->can_id),
- bcm_rx_handler, op, IDENT);
- }
-
- return msg_head->nframes * CFSIZ + MHSIZ;
-}
-
-static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk)
-{
- struct sk_buff *skb;
- struct net_device *dev;
- int err;
-
- /* just copy and send one can_frame */
-
- if (!ifindex) /* we need a real device to send frames */
- return -ENODEV;
-
- skb = alloc_skb(CFSIZ, GFP_KERNEL);
-
- if (!skb)
- return -ENOMEM;
-
- err = memcpy_fromiovec(skb_put(skb, CFSIZ), msg->msg_iov, CFSIZ);
- if (err < 0) {
- kfree_skb(skb);
- return err;
- }
-
- DBG_FRAME("BCM: TX_SEND: sending frame",
- (struct can_frame *)skb->data);
-
- dev = dev_get_by_index(ifindex);
- if (!dev) {
- kfree_skb(skb);
- return -ENODEV;
- }
-
- skb->dev = dev;
- skb->sk = sk;
- can_send(skb, 1); /* send with loopback */
- dev_put(dev);
-
- return CFSIZ + MHSIZ;
-}
-
-static int bcm_read_op(struct list_head *ops, struct bcm_msg_head *msg_head,
- int ifindex)
-{
- struct bcm_op *op;
- int ret;
-
- op = bcm_find_op(ops, msg_head->can_id, ifindex);
- if (op) {
-
- DBG("TRX_READ: sending status for can_id %03X\n",
- msg_head->can_id);
- /* put current values into msg_head */
- msg_head->flags = op->flags;
- msg_head->count = op->count;
- msg_head->ival1 = op->ival1;
- msg_head->ival2 = op->ival2;
- msg_head->nframes = op->nframes;
-
- bcm_send_to_user(op, msg_head, op->frames, NULL);
-
- ret = MHSIZ;
-
- } else {
-
- DBG("TRX_READ: did not find op for can_id %03X\n",
- msg_head->can_id);
- ret = -EINVAL;
- }
-
- return ret;
-}
-
-/* procfs functions */
-
-static char *bcm_proc_getifname(int ifindex)
-{
- struct net_device *dev;
-
- if (!ifindex)
- return "any";
-
- dev = __dev_get_by_index(ifindex); /* no usage counting */
- if (dev)
- return dev->name;
-
- return "???";
-}
-
-static int bcm_read_proc(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- int len = 0;
- struct sock *sk = (struct sock *)data;
- struct bcm_opt *bo = bcm_sk(sk);
- struct bcm_op *op;
-
- len += snprintf(page + len, PAGE_SIZE - len, ">>> socket %p",
- sk->sk_socket);
- len += snprintf(page + len, PAGE_SIZE - len, " / sk %p", sk);
- len += snprintf(page + len, PAGE_SIZE - len, " / bo %p", bo);
- len += snprintf(page + len, PAGE_SIZE - len, " / dropped %lu",
- bo->dropped_usr_msgs);
- len += snprintf(page + len, PAGE_SIZE - len, " / bound %s",
- bcm_proc_getifname(bo->ifindex));
- len += snprintf(page + len, PAGE_SIZE - len, " <<<\n");
-
- list_for_each_entry(op, &bo->rx_ops, list) {
-
- unsigned long reduction;
-
- /* print only active entries & prevent division by zero */
- if (!op->frames_abs)
- continue;
-
- len += snprintf(page + len, PAGE_SIZE - len,
- "rx_op: %03X %-5s ",
- op->can_id, bcm_proc_getifname(op->ifindex));
- len += snprintf(page + len, PAGE_SIZE - len, "[%d]%c ",
- op->nframes,
- (op->flags & RX_CHECK_DLC)?'d':' ');
- if (op->j_ival1)
- len += snprintf(page + len, PAGE_SIZE - len,
- "timeo=%ld ", op->j_ival1);
-
- if (op->j_ival2)
- len += snprintf(page + len, PAGE_SIZE - len,
- "thr=%ld ", op->j_ival2);
-
- len += snprintf(page + len, PAGE_SIZE - len,
- "# recv %ld (%ld) => reduction: ",
- op->frames_filtered, op->frames_abs);
-
- reduction = 100 - (op->frames_filtered * 100) / op->frames_abs;
-
- len += snprintf(page + len, PAGE_SIZE - len, "%s%ld%%\n",
- (reduction == 100)?"near ":"", reduction);
-
- if (len > PAGE_SIZE - 200) {
- /* mark output cut off */
- len += snprintf(page + len, PAGE_SIZE - len, "(..)\n");
- break;
- }
- }
-
- list_for_each_entry(op, &bo->tx_ops, list) {
-
- len += snprintf(page + len, PAGE_SIZE - len,
- "tx_op: %03X %s [%d] ",
- op->can_id, bcm_proc_getifname(op->ifindex),
- op->nframes);
- if (op->j_ival1)
- len += snprintf(page + len, PAGE_SIZE - len, "t1=%ld ",
- op->j_ival1);
-
- if (op->j_ival2)
- len += snprintf(page + len, PAGE_SIZE - len, "t2=%ld ",
- op->j_ival2);
-
- len += snprintf(page + len, PAGE_SIZE - len, "# sent %ld\n",
- op->frames_abs);
-
- if (len > PAGE_SIZE - 100) {
- /* mark output cut off */
- len += snprintf(page + len, PAGE_SIZE - len, "(..)\n");
- break;
}
- }
-
- len += snprintf(page + len, PAGE_SIZE - len, "\n");
-
- *eof = 1;
- return len;
-}
-/* bcm_op handling tx path */
+ /* bcm_can_tx / bcm_tx_timeout_handler needs this */
+ op->sk = sk;
+ op->ifindex = ifindex;
-static void bcm_can_tx(struct bcm_op *op)
-{
- struct sk_buff *skb;
- struct net_device *dev;
- struct can_frame *cf = &op->frames[op->currframe];
+ /* initialize uninitialized (kzalloc) structure */
+ hrtimer_init(&op->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ op->timer.function = bcm_rx_timeout_handler;
- DBG_FRAME("BCM: bcm_can_tx: sending frame", cf);
+ /* initialize tasklet for rx timeout notification */
+ tasklet_init(&op->tsklet, bcm_rx_timeout_tsklet,
+ (unsigned long) op);
- /* no target device? => exit */
- if (!op->ifindex)
- return;
+ hrtimer_init(&op->thrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ op->thrtimer.function = bcm_rx_thr_handler;
- dev = dev_get_by_index(op->ifindex);
+ /* initialize tasklet for rx throttle handling */
+ tasklet_init(&op->thrtsklet, bcm_rx_thr_tsklet,
+ (unsigned long) op);
- if (!dev) {
- /* RFC: should this bcm_op remove itself here? */
- return;
- }
+ /* add this bcm_op to the list of the rx_ops */
+ list_add(&op->list, &bo->rx_ops);
- skb = alloc_skb(CFSIZ,
- in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
+ /* call can_rx_register() */
+ do_rx_register = 1;
- if (!skb)
- goto out;
+ } /* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */
- memcpy(skb_put(skb, CFSIZ), cf, CFSIZ);
+ /* check flags */
+ op->flags = msg_head->flags;
- /* send with loopback */
- skb->dev = dev;
- skb->sk = op->sk;
- can_send(skb, 1);
+ if (op->flags & RX_RTR_FRAME) {
- /* update statistics */
- op->currframe++;
- op->frames_abs++;
+ /* no timers in RTR-mode */
+ hrtimer_cancel(&op->thrtimer);
+ hrtimer_cancel(&op->timer);
- /* reached last frame? */
- if (op->currframe >= op->nframes)
- op->currframe = 0;
- out:
- dev_put(dev);
-}
+ /*
+ * funny feature in RX(!)_SETUP only for RTR-mode:
+ * copy can_id into frame BUT without RTR-flag to
+ * prevent a full-load-loopback-test ... ;-]
+ */
+ if ((op->flags & TX_CP_CAN_ID) ||
+ (op->frames[0].can_id == op->can_id))
+ op->frames[0].can_id = op->can_id & ~CAN_RTR_FLAG;
-static void bcm_tx_timeout_handler(unsigned long data)
-{
- struct bcm_op *op = (struct bcm_op*)data;
+ } else {
+ if (op->flags & SETTIMER) {
- DBG("Called with bcm_op %p\n", op);
+ /* set timer value */
+ op->ival1 = msg_head->ival1;
+ op->ival2 = msg_head->ival2;
+ op->kt_ival1 = timeval_to_ktime(msg_head->ival1);
+ op->kt_ival2 = timeval_to_ktime(msg_head->ival2);
- if (op->j_ival1 && (op->count > 0)) {
+ /* disable an active timer due to zero value? */
+ if (!op->kt_ival1.tv64)
+ hrtimer_cancel(&op->timer);
- op->count--;
+ /*
+ * In any case cancel the throttle timer, flush
+ * potentially blocked msgs and reset throttle handling
+ */
+ op->kt_lastmsg = ktime_set(0, 0);
+ hrtimer_cancel(&op->thrtimer);
+ bcm_rx_thr_flush(op, 1);
+ }
- if (!op->count && (op->flags & TX_COUNTEVT)) {
- /* create notification to user */
+ if ((op->flags & STARTTIMER) && op->kt_ival1.tv64)
+ hrtimer_start(&op->timer, op->kt_ival1,
+ HRTIMER_MODE_REL);
+ }
- struct bcm_msg_head msg_head;
+ /* now we can register for can_ids, if we added a new bcm_op */
+ if (do_rx_register) {
+ if (ifindex) {
+ struct net_device *dev;
- DBG("sending TX_EXPIRED for can_id %03X\n",
- op->can_id);
+ dev = dev_get_by_index(&init_net, ifindex);
+ if (dev) {
+ err = can_rx_register(dev, op->can_id,
+ REGMASK(op->can_id),
+ bcm_rx_handler, op,
+ "bcm");
- msg_head.opcode = TX_EXPIRED;
- msg_head.flags = op->flags;
- msg_head.count = op->count;
- msg_head.ival1 = op->ival1;
- msg_head.ival2 = op->ival2;
- msg_head.can_id = op->can_id;
- msg_head.nframes = 0;
+ op->rx_reg_dev = dev;
+ dev_put(dev);
+ }
- bcm_send_to_user(op, &msg_head, NULL, NULL);
+ } else
+ err = can_rx_register(NULL, op->can_id,
+ REGMASK(op->can_id),
+ bcm_rx_handler, op, "bcm");
+ if (err) {
+ /* this bcm rx op is broken -> remove it */
+ list_del(&op->list);
+ bcm_remove_op(op);
+ return err;
}
}
- DBG("count=%d j_ival1=%ld j_ival2=%ld\n",
- op->count, op->j_ival1, op->j_ival2);
+ return msg_head->nframes * CFSIZ + MHSIZ;
+}
- if (op->j_ival1 && (op->count > 0)) {
+/*
+ * bcm_tx_send - send a single CAN frame to the CAN interface (for bcm_sendmsg)
+ */
+static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk)
+{
+ struct sk_buff *skb;
+ struct net_device *dev;
+ int err;
- op->timer.expires = jiffies + op->j_ival1;
- add_timer(&op->timer);
+ /* we need a real device to send frames */
+ if (!ifindex)
+ return -ENODEV;
- DBG("adding timer ival1. func=%p data=%p exp=0x%08X\n",
- op->timer.function,
- (char*) op->timer.data,
- (unsigned int) op->timer.expires);
+ skb = alloc_skb(CFSIZ, GFP_KERNEL);
- /* send (next) frame */
- bcm_can_tx(op);
- } else {
- if (op->j_ival2) {
- op->timer.expires = jiffies + op->j_ival2;
- add_timer(&op->timer);
+ if (!skb)
+ return -ENOMEM;
- DBG("adding timer ival2. func=%p data=%p exp=0x%08X\n",
- op->timer.function,
- (char*) op->timer.data,
- (unsigned int) op->timer.expires);
+ err = memcpy_fromiovec(skb_put(skb, CFSIZ), msg->msg_iov, CFSIZ);
+ if (err < 0) {
+ kfree_skb(skb);
+ return err;
+ }
- /* send (next) frame */
- bcm_can_tx(op);
- } else
- DBG("no timer restart\n");
+ dev = dev_get_by_index(&init_net, ifindex);
+ if (!dev) {
+ kfree_skb(skb);
+ return -ENODEV;
}
- return;
+ skb->dev = dev;
+ skb->sk = sk;
+ err = can_send(skb, 1); /* send with loopback */
+ dev_put(dev);
-}
+ if (err)
+ return err;
-/* bcm_op handling rx path */
+ return CFSIZ + MHSIZ;
+}
-static void bcm_rx_handler(struct sk_buff *skb, void *data)
+/*
+ * bcm_sendmsg - process BCM commands (opcodes) from the userspace
+ */
+static int bcm_sendmsg(struct kiocb *iocb, struct socket *sock,
+ struct msghdr *msg, size_t size)
{
- struct bcm_op *op = (struct bcm_op*)data;
- struct can_frame rxframe;
- int i;
-
- /* disable timeout */
- del_timer(&op->timer);
-
- DBG("Called with bcm_op %p\n", op);
-
- if (skb->len == sizeof(rxframe)) {
- memcpy(&rxframe, skb->data, sizeof(rxframe));
- /* save rx timestamp */
- skb_get_timestamp(skb, &op->rx_stamp);
- /* save originator for recvfrom() */
- op->rx_ifindex = skb->dev->ifindex;
- /* update statistics */
- op->frames_abs++;
- kfree_skb(skb);
- DBG("got can_frame with can_id %03X\n", rxframe.can_id);
- } else {
- DBG("Wrong skb->len = %d\n", skb->len);
- kfree_skb(skb);
- return;
- }
-
- DBG_FRAME("BCM: bcm_rx_handler: CAN frame", &rxframe);
-
- if (op->can_id != rxframe.can_id) {
- DBG("ERROR! Got wrong can_id %03X! Expected %03X.\n",
- rxframe.can_id, op->can_id);
- return;
- }
+ struct sock *sk = sock->sk;
+ struct bcm_sock *bo = bcm_sk(sk);
+ int ifindex = bo->ifindex; /* default ifindex for this bcm_op */
+ struct bcm_msg_head msg_head;
+ int ret; /* read bytes or error codes as return value */
- if (op->flags & RX_RTR_FRAME) {
- /* send reply for RTR-request */
- DBG("RTR-request\n");
+ if (!bo->bound)
+ return -ENOTCONN;
- /* send op->frames[0] to CAN device */
- bcm_can_tx(op);
- return;
- }
+ /* check for valid message length from userspace */
+ if (size < MHSIZ || (size - MHSIZ) % CFSIZ)
+ return -EINVAL;
- if (op->flags & RX_FILTER_ID) {
- /* the easiest case */
- DBG("Easy does it with RX_FILTER_ID\n");
+ /* check for alternative ifindex for this bcm_op */
- bcm_rx_update_and_send(op, &op->last_frames[0], &rxframe);
- bcm_rx_starttimer(op);
- return;
- }
+ if (!ifindex && msg->msg_name) {
+ /* no bound device as default => check msg_name */
+ struct sockaddr_can *addr =
+ (struct sockaddr_can *)msg->msg_name;
- if (op->nframes == 1) {
- /* simple compare with index 0 */
- DBG("Simple compare\n");
+ if (msg->msg_namelen < sizeof(*addr))
+ return -EINVAL;
- bcm_rx_cmp_to_index(op, 0, &rxframe);
- bcm_rx_starttimer(op);
- return;
- }
+ if (addr->can_family != AF_CAN)
+ return -EINVAL;
- if (op->nframes > 1) {
- /* multiplex compare */
- DBG("Multiplex compare\n");
+ /* ifindex from sendto() */
+ ifindex = addr->can_ifindex;
- /*
- * find the first multiplex mask that fits.
- * Remark: The MUX-mask is stored in index 0
- */
+ if (ifindex) {
+ struct net_device *dev;
- for (i=1; i < op->nframes; i++) {
+ dev = dev_get_by_index(&init_net, ifindex);
+ if (!dev)
+ return -ENODEV;
- if ((GET_U64(&op->frames[0]) & GET_U64(&rxframe)) ==
- (GET_U64(&op->frames[0]) &
- GET_U64(&op->frames[i]))) {
- DBG("found MUX index %d\n", i);
- bcm_rx_cmp_to_index(op, i, &rxframe);
- break;
+ if (dev->type != ARPHRD_CAN) {
+ dev_put(dev);
+ return -ENODEV;
}
+
+ dev_put(dev);
}
- bcm_rx_starttimer(op);
}
-}
-static void bcm_rx_cmp_to_index(struct bcm_op *op, int index,
- struct can_frame *rxdata)
-{
- /*
- * no one uses the MSBs of can_dlc for comparation,
- * so we use it here to detect the first time of reception
- */
+ /* read message head information */
- if (!(op->last_frames[index].can_dlc & RX_RECV)) {
- /* received data for the first time => send update to user */
- DBG("first time :)\n");
- bcm_rx_update_and_send(op, &op->last_frames[index], rxdata);
- return;
- }
+ ret = memcpy_fromiovec((u8 *)&msg_head, msg->msg_iov, MHSIZ);
+ if (ret < 0)
+ return ret;
- /* do a real check in can_data */
+ lock_sock(sk);
- DBG("op->frames[index].data = 0x%016llx\n",
- GET_U64(&op->frames[index]));
- DBG("op->last_frames[index].data = 0x%016llx\n",
- GET_U64(&op->last_frames[index]));
- DBG("rxdata->data = 0x%016llx\n", GET_U64(rxdata));
+ switch (msg_head.opcode) {
- if ((GET_U64(&op->frames[index]) & GET_U64(rxdata)) !=
- (GET_U64(&op->frames[index]) & GET_U64(&op->last_frames[index]))) {
- DBG("relevant data change :)\n");
- bcm_rx_update_and_send(op, &op->last_frames[index], rxdata);
- return;
- }
+ case TX_SETUP:
+ ret = bcm_tx_setup(&msg_head, msg, ifindex, sk);
+ break;
+ case RX_SETUP:
+ ret = bcm_rx_setup(&msg_head, msg, ifindex, sk);
+ break;
- if (op->flags & RX_CHECK_DLC) {
+ case TX_DELETE:
+ if (bcm_delete_tx_op(&bo->tx_ops, msg_head.can_id, ifindex))
+ ret = MHSIZ;
+ else
+ ret = -EINVAL;
+ break;
+
+ case RX_DELETE:
+ if (bcm_delete_rx_op(&bo->rx_ops, msg_head.can_id, ifindex))
+ ret = MHSIZ;
+ else
+ ret = -EINVAL;
+ break;
- /* do a real check in dlc */
+ case TX_READ:
+ /* reuse msg_head for the reply to TX_READ */
+ msg_head.opcode = TX_STATUS;
+ ret = bcm_read_op(&bo->tx_ops, &msg_head, ifindex);
+ break;
- if (rxdata->can_dlc != (op->last_frames[index].can_dlc &
- BCM_CAN_DLC_MASK)) {
- DBG("dlc change :)\n");
- bcm_rx_update_and_send(op, &op->last_frames[index],
- rxdata);
- return;
- }
+ case RX_READ:
+ /* reuse msg_head for the reply to RX_READ */
+ msg_head.opcode = RX_STATUS;
+ ret = bcm_read_op(&bo->rx_ops, &msg_head, ifindex);
+ break;
+
+ case TX_SEND:
+ /* we need exactly one can_frame behind the msg head */
+ if ((msg_head.nframes != 1) || (size != CFSIZ + MHSIZ))
+ ret = -EINVAL;
+ else
+ ret = bcm_tx_send(msg, ifindex, sk);
+ break;
+
+ default:
+ ret = -EINVAL;
+ break;
}
- DBG("no relevant change :(\n");
+
+ release_sock(sk);
+
+ return ret;
}
-static void bcm_rx_update_and_send(struct bcm_op *op,
- struct can_frame *lastdata,
- struct can_frame *rxdata)
+/*
+ * notification handler for netdevice status changes
+ */
+static int bcm_notifier(struct notifier_block *nb, unsigned long msg,
+ void *data)
{
- unsigned long nexttx = op->j_lastmsg + op->j_ival2;
+ struct net_device *dev = (struct net_device *)data;
+ struct bcm_sock *bo = container_of(nb, struct bcm_sock, notifier);
+ struct sock *sk = &bo->sk;
+ struct bcm_op *op;
+ int notify_enodev = 0;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+ if (!net_eq(dev_net(dev), &init_net))
+ return NOTIFY_DONE;
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
+ if (dev->nd_net != &init_net)
+ return NOTIFY_DONE;
+#endif
- memcpy(lastdata, rxdata, CFSIZ);
+ if (dev->type != ARPHRD_CAN)
+ return NOTIFY_DONE;
- /* mark as used */
- lastdata->can_dlc |= RX_RECV;
+ switch (msg) {
- /* throttle bcm_rx_changed ? */
- if ((op->thrtimer.expires) ||
- ((op->j_ival2) && (nexttx > jiffies))) {
- /* we are already waiting OR we have to start waiting */
+ case NETDEV_UNREGISTER:
+ lock_sock(sk);
+
+ /* remove device specific receive entries */
+ list_for_each_entry(op, &bo->rx_ops, list)
+ if (op->rx_reg_dev == dev)
+ bcm_rx_unreg(dev, op);
+
+ /* remove device reference, if this is our bound device */
+ if (bo->bound && bo->ifindex == dev->ifindex) {
+ bo->bound = 0;
+ bo->ifindex = 0;
+ notify_enodev = 1;
+ }
- /* mark as 'throttled' */
- lastdata->can_dlc |= RX_THR;
+ release_sock(sk);
- if (!(op->thrtimer.expires)) {
- /* start the timer only the first time */
- op->thrtimer.expires = nexttx;
- add_timer(&op->thrtimer);
+ if (notify_enodev) {
+ sk->sk_err = ENODEV;
+ if (!sock_flag(sk, SOCK_DEAD))
+ sk->sk_error_report(sk);
+ }
+ break;
- DBG("adding thrtimer. func=%p data=%p exp=0x%08X\n",
- op->thrtimer.function,
- (char*) op->thrtimer.data,
- (unsigned int) op->thrtimer.expires);
+ case NETDEV_DOWN:
+ if (bo->bound && bo->ifindex == dev->ifindex) {
+ sk->sk_err = ENETDOWN;
+ if (!sock_flag(sk, SOCK_DEAD))
+ sk->sk_error_report(sk);
}
- } else {
- /* send RX_CHANGED to the user */
- bcm_rx_changed(op, rxdata);
}
+
+ return NOTIFY_DONE;
}
-static void bcm_rx_starttimer(struct bcm_op *op)
+/*
+ * initial settings for all BCM sockets to be set at socket creation time
+ */
+static int bcm_init(struct sock *sk)
{
- if (op->flags & RX_NO_AUTOTIMER)
- return;
+ struct bcm_sock *bo = bcm_sk(sk);
+
+ bo->bound = 0;
+ bo->ifindex = 0;
+ bo->dropped_usr_msgs = 0;
+ bo->bcm_proc_read = NULL;
- if (op->j_ival1) {
+ INIT_LIST_HEAD(&bo->tx_ops);
+ INIT_LIST_HEAD(&bo->rx_ops);
- op->timer.expires = jiffies + op->j_ival1;
+ /* set notifier */
+ bo->notifier.notifier_call = bcm_notifier;
- DBG("adding rx timeout timer ival1. func=%p data=%p "
- "exp=0x%08X\n",
- op->timer.function,
- (char*) op->timer.data,
- (unsigned int) op->timer.expires);
+ register_netdevice_notifier(&bo->notifier);
- add_timer(&op->timer);
- }
+ return 0;
}
-
-static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data)
+/*
+ * standard socket functions
+ */
+static int bcm_release(struct socket *sock)
{
- struct bcm_msg_head head;
+ struct sock *sk = sock->sk;
+ struct bcm_sock *bo;
+ struct bcm_op *op, *next;
- op->j_lastmsg = jiffies;
+ if (sk == NULL)
+ return 0;
- /* update statistics */
- op->frames_filtered++;
+ bo = bcm_sk(sk);
- /* prevent statistics overflow */
- if (op->frames_filtered > ULONG_MAX/100)
- op->frames_filtered = op->frames_abs = 0;
+ /* remove bcm_ops, timer, rx_unregister(), etc. */
- DBG("setting j_lastmsg to 0x%08X for rx_op %p\n",
- (unsigned int) op->j_lastmsg, op);
- DBG("sending notification\n");
+ unregister_netdevice_notifier(&bo->notifier);
- head.opcode = RX_CHANGED;
- head.flags = op->flags;
- head.count = op->count;
- head.ival1 = op->ival1;
- head.ival2 = op->ival2;
- head.can_id = op->can_id;
- head.nframes = 1;
+ lock_sock(sk);
- bcm_send_to_user(op, &head, data, &op->rx_stamp);
-}
+ list_for_each_entry_safe(op, next, &bo->tx_ops, list)
+ bcm_remove_op(op);
+ list_for_each_entry_safe(op, next, &bo->rx_ops, list) {
+ /*
+ * Don't care if we're bound or not (due to netdev problems)
+ * can_rx_unregister() is always a save thing to do here.
+ */
+ if (op->ifindex) {
+ /*
+ * Only remove subscriptions that had not
+ * been removed due to NETDEV_UNREGISTER
+ * in bcm_notifier()
+ */
+ if (op->rx_reg_dev) {
+ struct net_device *dev;
-static void bcm_rx_timeout_handler(unsigned long data)
-{
- struct bcm_op *op = (struct bcm_op*)data;
- struct bcm_msg_head msg_head;
+ dev = dev_get_by_index(&init_net, op->ifindex);
+ if (dev) {
+ bcm_rx_unreg(dev, op);
+ dev_put(dev);
+ }
+ }
+ } else
+ can_rx_unregister(NULL, op->can_id,
+ REGMASK(op->can_id),
+ bcm_rx_handler, op);
- DBG("sending RX_TIMEOUT for can_id %03X. op is %p\n", op->can_id, op);
+ bcm_remove_op(op);
+ }
- msg_head.opcode = RX_TIMEOUT;
- msg_head.flags = op->flags;
- msg_head.count = op->count;
- msg_head.ival1 = op->ival1;
- msg_head.ival2 = op->ival2;
- msg_head.can_id = op->can_id;
- msg_head.nframes = 0;
+ /* remove procfs entry */
+ if (proc_dir && bo->bcm_proc_read)
+ remove_proc_entry(bo->procname, proc_dir);
- bcm_send_to_user(op, &msg_head, NULL, NULL);
+ /* remove device reference */
+ if (bo->bound) {
+ bo->bound = 0;
+ bo->ifindex = 0;
+ }
- /* no restart of the timer is done here! */
+ sock_orphan(sk);
+ sock->sk = NULL;
- /* if user wants to be informed, when cyclic CAN-Messages come back */
- if ((op->flags & RX_ANNOUNCE_RESUME) && op->last_frames) {
- /* clear received can_frames to indicate 'nothing received' */
- memset(op->last_frames, 0, op->nframes * CFSIZ);
- DBG("RX_ANNOUNCE_RESTART\n");
- }
+ release_sock(sk);
+ sock_put(sk);
+ return 0;
}
-static void bcm_rx_thr_handler(unsigned long data)
+static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len,
+ int flags)
{
- struct bcm_op *op = (struct bcm_op*)data;
- int i = 0;
+ struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
+ struct sock *sk = sock->sk;
+ struct bcm_sock *bo = bcm_sk(sk);
- /* mark disabled / consumed timer */
- op->thrtimer.expires = 0;
+ if (len < sizeof(*addr))
+ return -EINVAL;
- if (op->nframes > 1){
+ if (bo->bound)
+ return -EISCONN;
- DBG("sending MUX RX_CHANGED for can_id %03X. op is %p\n",
- op->can_id, op);
- /* for MUX filter we start at index 1 */
- for (i=1; i<op->nframes; i++){
- if ((op->last_frames) &&
- (op->last_frames[i].can_dlc & RX_THR)){
- op->last_frames[i].can_dlc &= ~RX_THR;
- bcm_rx_changed(op, &op->last_frames[i]);
- }
+ /* bind a device to this socket */
+ if (addr->can_ifindex) {
+ struct net_device *dev;
+
+ dev = dev_get_by_index(&init_net, addr->can_ifindex);
+ if (!dev)
+ return -ENODEV;
+
+ if (dev->type != ARPHRD_CAN) {
+ dev_put(dev);
+ return -ENODEV;
}
+
+ bo->ifindex = dev->ifindex;
+ dev_put(dev);
+
} else {
+ /* no interface reference for ifindex = 0 ('any' CAN device) */
+ bo->ifindex = 0;
+ }
- DBG("sending simple RX_CHANGED for can_id %03X. op is %p\n",
- op->can_id, op);
- /* for RX_FILTER_ID and simple filter */
- if (op->last_frames && (op->last_frames[0].can_dlc & RX_THR)){
- op->last_frames[0].can_dlc &= ~RX_THR;
- bcm_rx_changed(op, &op->last_frames[0]);
- }
+ bo->bound = 1;
+
+ if (proc_dir) {
+ /* unique socket address as filename */
+ sprintf(bo->procname, "%lu", sock_i_ino(sk));
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+ bo->bcm_proc_read = proc_create_data(bo->procname, 0644,
+ proc_dir,
+ &bcm_proc_fops, sk);
+#else
+ bo->bcm_proc_read = create_proc_read_entry(bo->procname, 0644,
+ proc_dir,
+ bcm_read_proc, sk);
+#endif
}
+
+ return 0;
}
-static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,
- struct can_frame *frames, struct timeval *tv)
+static int bcm_recvmsg(struct kiocb *iocb, struct socket *sock,
+ struct msghdr *msg, size_t size, int flags)
{
+ struct sock *sk = sock->sk;
struct sk_buff *skb;
- struct can_frame *firstframe;
- struct sock *sk = op->sk;
- int datalen = head->nframes * CFSIZ;
- struct sockaddr_can *addr;
+ int error = 0;
+ int noblock;
int err;
- skb = alloc_skb(sizeof(*head) + datalen,
- in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
+ noblock = flags & MSG_DONTWAIT;
+ flags &= ~MSG_DONTWAIT;
+ skb = skb_recv_datagram(sk, flags, noblock, &error);
if (!skb)
- return;
-
- memcpy(skb_put(skb, sizeof(*head)), head, sizeof(*head));
-
- /* can_frames starting here */
- firstframe = (struct can_frame *) skb->tail;
+ return error;
- if (tv)
- skb_set_timestamp(skb, tv); /* restore timestamp */
+ if (skb->len < size)
+ size = skb->len;
- addr = (struct sockaddr_can *)skb->cb;
- memset(addr, 0, sizeof(*addr));
- addr->can_family = AF_CAN;
- /* restore originator for recvfrom() */
- addr->can_ifindex = op->rx_ifindex;
+ err = memcpy_toiovec(msg->msg_iov, skb->data, size);
+ if (err < 0) {
+ skb_free_datagram(sk, skb);
+ return err;
+ }
- if (head->nframes){
- memcpy(skb_put(skb, datalen), frames, datalen);
+ sock_recv_timestamp(msg, sk, skb);
- /*
- * the BCM uses the can_dlc-element of the can_frame
- * structure for internal purposes. This is only
- * relevant for updates that are generated by the
- * BCM, where nframes is 1
- */
- if (head->nframes == 1)
- firstframe->can_dlc &= BCM_CAN_DLC_MASK;
+ if (msg->msg_name) {
+ msg->msg_namelen = sizeof(struct sockaddr_can);
+ memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
}
- err = sock_queue_rcv_skb(sk, skb);
- if (err < 0) {
- struct bcm_opt *bo = bcm_sk(sk);
+ skb_free_datagram(sk, skb);
- DBG("sock_queue_rcv_skb failed: %d\n", err);
- kfree_skb(skb);
- /* don't care about overflows in this statistic */
- bo->dropped_usr_msgs++;
- }
+ return size;
}
-/* bcm_op handling: find & delete bcm_op elements */
-
-static struct bcm_op *bcm_find_op(struct list_head *ops, canid_t can_id,
- int ifindex)
-{
- struct bcm_op *op;
+static const struct proto_ops bcm_ops = {
+ .family = PF_CAN,
+ .release = bcm_release,
+ .bind = sock_no_bind,
+ .connect = bcm_connect,
+ .socketpair = sock_no_socketpair,
+ .accept = sock_no_accept,
+ .getname = sock_no_getname,
+ .poll = datagram_poll,
+ .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */
+ .listen = sock_no_listen,
+ .shutdown = sock_no_shutdown,
+ .setsockopt = sock_no_setsockopt,
+ .getsockopt = sock_no_getsockopt,
+ .sendmsg = bcm_sendmsg,
+ .recvmsg = bcm_recvmsg,
+ .mmap = sock_no_mmap,
+ .sendpage = sock_no_sendpage,
+};
- list_for_each_entry(op, ops, list) {
- if ((op->can_id == can_id) && (op->ifindex == ifindex))
- return op;
- }
+static struct proto bcm_proto __read_mostly = {
+ .name = "CAN_BCM",
+ .owner = THIS_MODULE,
+ .obj_size = sizeof(struct bcm_sock),
+ .init = bcm_init,
+};
- return NULL;
-}
+static const struct can_proto bcm_can_proto = {
+ .type = SOCK_DGRAM,
+ .protocol = CAN_BCM,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)
+ .capability = -1,
+#endif
+ .ops = &bcm_ops,
+ .prot = &bcm_proto,
+};
-static int bcm_delete_rx_op(struct list_head *ops, canid_t can_id, int ifindex)
+static int __init bcm_module_init(void)
{
- struct bcm_op *op, *n;
-
- list_for_each_entry_safe(op, n, ops, list) {
- if ((op->can_id == can_id) && (op->ifindex == ifindex)) {
- DBG("removing rx_op %p for can_id %03X\n",
- op, op->can_id);
-
- /*
- * Don't care if we're bound or not (due to netdev
- * problems) can_rx_unregister() is always a save
- * thing to do here.
- */
- if (op->ifindex) {
- struct net_device *dev =
- dev_get_by_index(op->ifindex);
+ int err;
- if (dev) {
- can_rx_unregister(dev, op->can_id,
- REGMASK(op->can_id),
- bcm_rx_handler, op);
- dev_put(dev);
- }
- } else
- can_rx_unregister(NULL, op->can_id,
- REGMASK(op->can_id),
- bcm_rx_handler, op);
+ printk(banner);
- list_del(&op->list);
- bcm_remove_op(op);
- return 1; /* done */
- }
+ err = can_proto_register(&bcm_can_proto);
+ if (err < 0) {
+ printk(KERN_ERR "can: registration of bcm protocol failed\n");
+ return err;
}
- return 0; /* not found */
-}
-
-static int bcm_delete_tx_op(struct list_head *ops, canid_t can_id, int ifindex)
-{
- struct bcm_op *op, *n;
+ /* create /proc/net/can-bcm directory */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
+ proc_dir = proc_mkdir("can-bcm", init_net.proc_net);
+#else
+ proc_dir = proc_mkdir("can-bcm", proc_net);
+#endif
- list_for_each_entry_safe(op, n, ops, list) {
- if ((op->can_id == can_id) && (op->ifindex == ifindex)) {
- DBG("removing rx_op %p for can_id %03X\n",
- op, op->can_id);
- list_del(&op->list);
- bcm_remove_op(op);
- return 1; /* done */
- }
- }
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
+ if (proc_dir)
+ proc_dir->owner = THIS_MODULE;
+#endif
- return 0; /* not found */
+ return 0;
}
-static void bcm_remove_op(struct bcm_op *op)
+static void __exit bcm_module_exit(void)
{
- del_timer(&op->timer);
- del_timer(&op->thrtimer);
- if (op->frames)
- kfree(op->frames);
- if (op->last_frames)
- kfree(op->last_frames);
- kfree(op);
+ can_proto_unregister(&bcm_can_proto);
- return;
+ if (proc_dir)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
+ proc_net_remove(&init_net, "can-bcm");
+#else
+ proc_net_remove("can-bcm");
+#endif
}
module_init(bcm_module_init);