2 * bcm.c - Broadcast Manager to filter/send (cyclic) CAN content
4 * Copyright (c) 2002-2016 Volkswagen Group Electronic Research
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of Volkswagen nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * Alternatively, provided that this notice is retained in full, this
20 * software may be distributed under the terms of the GNU General
21 * Public License ("GPL") version 2, in which case the provisions of the
22 * GPL apply INSTEAD OF those given above.
24 * The provided data structures and external interfaces from this code
25 * are not restricted to be used by modules with a GPL compatible license.
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/interrupt.h>
45 #include <linux/hrtimer.h>
46 #include <linux/list.h>
47 #include <linux/proc_fs.h>
48 #include <linux/seq_file.h>
49 #include <linux/uio.h>
50 #include <linux/net.h>
51 #include <linux/netdevice.h>
52 #include <linux/socket.h>
53 #include <linux/if_arp.h>
54 #include <linux/skbuff.h>
55 #include <linux/can.h>
56 #include <linux/can/core.h>
57 #include <linux/can/skb.h>
58 #include <linux/can/bcm.h>
59 #include <linux/slab.h>
61 #include <net/net_namespace.h>
64 * To send multiple CAN frame content within TX_SETUP or to filter
65 * CAN messages with multiplex index within RX_SETUP, the number of
66 * different filters is limited to 256 due to the one byte index value.
68 #define MAX_NFRAMES 256
70 /* use of last_frames[index].flags */
71 #define RX_RECV 0x40 /* received data for this element */
72 #define RX_THR 0x80 /* element not been sent due to throttle feature */
73 #define BCM_CAN_FLAGS_MASK 0x3F /* to clean private flags after usage */
75 /* get best masking value for can_rx_register() for a given single can_id */
76 #define REGMASK(id) ((id & CAN_EFF_FLAG) ? \
77 (CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG) : \
78 (CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG))
80 #define CAN_BCM_VERSION "20161123"
82 MODULE_DESCRIPTION("PF_CAN broadcast manager protocol");
83 MODULE_LICENSE("Dual BSD/GPL");
84 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
85 MODULE_ALIAS("can-proto-2");
88 * easy access to the first 64 bit of can(fd)_frame payload. cp->data is
89 * 64 bit aligned so the offset has to be multiples of 8 which is ensured
90 * by the only callers in bcm_rx_cmp_to_index() bcm_rx_handler().
92 static inline u64
get_u64(const struct canfd_frame
*cp
, int offset
)
94 return *(u64
*)(cp
->data
+ offset
);
98 struct list_head list
;
102 unsigned long frames_abs
, frames_filtered
;
103 struct bcm_timeval ival1
, ival2
;
104 struct hrtimer timer
, thrtimer
;
105 struct tasklet_struct tsklet
, thrtsklet
;
106 ktime_t rx_stamp
, kt_ival1
, kt_ival2
, kt_lastmsg
;
112 /* void pointers to arrays of struct can[fd]_frame */
115 struct canfd_frame sframe
;
116 struct canfd_frame last_sframe
;
118 struct net_device
*rx_reg_dev
;
121 static struct proc_dir_entry
*proc_dir
;
127 struct notifier_block notifier
;
128 struct list_head rx_ops
;
129 struct list_head tx_ops
;
130 unsigned long dropped_usr_msgs
;
131 struct proc_dir_entry
*bcm_proc_read
;
132 char procname
[32]; /* inode number in decimal with \0 */
135 static inline struct bcm_sock
*bcm_sk(const struct sock
*sk
)
137 return (struct bcm_sock
*)sk
;
140 static inline ktime_t
bcm_timeval_to_ktime(struct bcm_timeval tv
)
142 return ktime_set(tv
.tv_sec
, tv
.tv_usec
* NSEC_PER_USEC
);
145 #define CFSIZ(flags) ((flags & CAN_FD_FRAME) ? CANFD_MTU : CAN_MTU)
146 #define OPSIZ sizeof(struct bcm_op)
147 #define MHSIZ sizeof(struct bcm_msg_head)
152 static char *bcm_proc_getifname(char *result
, int ifindex
)
154 struct net_device
*dev
;
160 dev
= dev_get_by_index_rcu(&init_net
, ifindex
);
162 strcpy(result
, dev
->name
);
164 strcpy(result
, "???");
170 static int bcm_proc_show(struct seq_file
*m
, void *v
)
172 char ifname
[IFNAMSIZ
];
173 struct sock
*sk
= (struct sock
*)m
->private;
174 struct bcm_sock
*bo
= bcm_sk(sk
);
177 seq_printf(m
, ">>> socket %pK", sk
->sk_socket
);
178 seq_printf(m
, " / sk %pK", sk
);
179 seq_printf(m
, " / bo %pK", bo
);
180 seq_printf(m
, " / dropped %lu", bo
->dropped_usr_msgs
);
181 seq_printf(m
, " / bound %s", bcm_proc_getifname(ifname
, bo
->ifindex
));
182 seq_printf(m
, " <<<\n");
184 list_for_each_entry(op
, &bo
->rx_ops
, list
) {
186 unsigned long reduction
;
188 /* print only active entries & prevent division by zero */
192 seq_printf(m
, "rx_op: %03X %-5s ", op
->can_id
,
193 bcm_proc_getifname(ifname
, op
->ifindex
));
195 if (op
->flags
& CAN_FD_FRAME
)
196 seq_printf(m
, "(%u)", op
->nframes
);
198 seq_printf(m
, "[%u]", op
->nframes
);
200 seq_printf(m
, "%c ", (op
->flags
& RX_CHECK_DLC
) ? 'd' : ' ');
203 seq_printf(m
, "timeo=%lld ",
204 (long long)ktime_to_us(op
->kt_ival1
));
207 seq_printf(m
, "thr=%lld ",
208 (long long)ktime_to_us(op
->kt_ival2
));
210 seq_printf(m
, "# recv %ld (%ld) => reduction: ",
211 op
->frames_filtered
, op
->frames_abs
);
213 reduction
= 100 - (op
->frames_filtered
* 100) / op
->frames_abs
;
215 seq_printf(m
, "%s%ld%%\n",
216 (reduction
== 100) ? "near " : "", reduction
);
219 list_for_each_entry(op
, &bo
->tx_ops
, list
) {
221 seq_printf(m
, "tx_op: %03X %s ", op
->can_id
,
222 bcm_proc_getifname(ifname
, op
->ifindex
));
224 if (op
->flags
& CAN_FD_FRAME
)
225 seq_printf(m
, "(%u) ", op
->nframes
);
227 seq_printf(m
, "[%u] ", op
->nframes
);
230 seq_printf(m
, "t1=%lld ",
231 (long long)ktime_to_us(op
->kt_ival1
));
234 seq_printf(m
, "t2=%lld ",
235 (long long)ktime_to_us(op
->kt_ival2
));
237 seq_printf(m
, "# sent %ld\n", op
->frames_abs
);
243 static int bcm_proc_open(struct inode
*inode
, struct file
*file
)
245 return single_open(file
, bcm_proc_show
, PDE_DATA(inode
));
248 static const struct file_operations bcm_proc_fops
= {
249 .owner
= THIS_MODULE
,
250 .open
= bcm_proc_open
,
253 .release
= single_release
,
257 * bcm_can_tx - send the (next) CAN frame to the appropriate CAN interface
258 * of the given bcm tx op
260 static void bcm_can_tx(struct bcm_op
*op
)
263 struct net_device
*dev
;
264 struct canfd_frame
*cf
= op
->frames
+ op
->cfsiz
* op
->currframe
;
266 /* no target device? => exit */
270 dev
= dev_get_by_index(&init_net
, op
->ifindex
);
272 /* RFC: should this bcm_op remove itself here? */
276 skb
= alloc_skb(op
->cfsiz
+ sizeof(struct can_skb_priv
), gfp_any());
280 can_skb_reserve(skb
);
281 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
282 can_skb_prv(skb
)->skbcnt
= 0;
284 memcpy(skb_put(skb
, op
->cfsiz
), cf
, op
->cfsiz
);
286 /* send with loopback */
288 can_skb_set_owner(skb
, op
->sk
);
291 /* update statistics */
295 /* reached last frame? */
296 if (op
->currframe
>= op
->nframes
)
303 * bcm_send_to_user - send a BCM message to the userspace
304 * (consisting of bcm_msg_head + x CAN frames)
306 static void bcm_send_to_user(struct bcm_op
*op
, struct bcm_msg_head
*head
,
307 struct canfd_frame
*frames
, int has_timestamp
)
310 struct canfd_frame
*firstframe
;
311 struct sockaddr_can
*addr
;
312 struct sock
*sk
= op
->sk
;
313 unsigned int datalen
= head
->nframes
* op
->cfsiz
;
316 skb
= alloc_skb(sizeof(*head
) + datalen
, gfp_any());
320 memcpy(skb_put(skb
, sizeof(*head
)), head
, sizeof(*head
));
323 /* CAN frames starting here */
324 firstframe
= (struct canfd_frame
*)skb_tail_pointer(skb
);
326 memcpy(skb_put(skb
, datalen
), frames
, datalen
);
329 * the BCM uses the flags-element of the canfd_frame
330 * structure for internal purposes. This is only
331 * relevant for updates that are generated by the
332 * BCM, where nframes is 1
334 if (head
->nframes
== 1)
335 firstframe
->flags
&= BCM_CAN_FLAGS_MASK
;
339 /* restore rx timestamp */
340 skb
->tstamp
= op
->rx_stamp
;
344 * Put the datagram to the queue so that bcm_recvmsg() can
345 * get it from there. We need to pass the interface index to
346 * bcm_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
347 * containing the interface index.
350 sock_skb_cb_check_size(sizeof(struct sockaddr_can
));
351 addr
= (struct sockaddr_can
*)skb
->cb
;
352 memset(addr
, 0, sizeof(*addr
));
353 addr
->can_family
= AF_CAN
;
354 addr
->can_ifindex
= op
->rx_ifindex
;
356 err
= sock_queue_rcv_skb(sk
, skb
);
358 struct bcm_sock
*bo
= bcm_sk(sk
);
361 /* don't care about overflows in this statistic */
362 bo
->dropped_usr_msgs
++;
366 static void bcm_tx_start_timer(struct bcm_op
*op
)
368 if (op
->kt_ival1
&& op
->count
)
369 hrtimer_start(&op
->timer
,
370 ktime_add(ktime_get(), op
->kt_ival1
),
372 else if (op
->kt_ival2
)
373 hrtimer_start(&op
->timer
,
374 ktime_add(ktime_get(), op
->kt_ival2
),
378 static void bcm_tx_timeout_tsklet(unsigned long data
)
380 struct bcm_op
*op
= (struct bcm_op
*)data
;
381 struct bcm_msg_head msg_head
;
383 if (op
->kt_ival1
&& (op
->count
> 0)) {
386 if (!op
->count
&& (op
->flags
& TX_COUNTEVT
)) {
388 /* create notification to user */
389 msg_head
.opcode
= TX_EXPIRED
;
390 msg_head
.flags
= op
->flags
;
391 msg_head
.count
= op
->count
;
392 msg_head
.ival1
= op
->ival1
;
393 msg_head
.ival2
= op
->ival2
;
394 msg_head
.can_id
= op
->can_id
;
395 msg_head
.nframes
= 0;
397 bcm_send_to_user(op
, &msg_head
, NULL
, 0);
401 } else if (op
->kt_ival2
)
404 bcm_tx_start_timer(op
);
408 * bcm_tx_timeout_handler - performs cyclic CAN frame transmissions
410 static enum hrtimer_restart
bcm_tx_timeout_handler(struct hrtimer
*hrtimer
)
412 struct bcm_op
*op
= container_of(hrtimer
, struct bcm_op
, timer
);
414 tasklet_schedule(&op
->tsklet
);
416 return HRTIMER_NORESTART
;
420 * bcm_rx_changed - create a RX_CHANGED notification due to changed content
422 static void bcm_rx_changed(struct bcm_op
*op
, struct canfd_frame
*data
)
424 struct bcm_msg_head head
;
426 /* update statistics */
427 op
->frames_filtered
++;
429 /* prevent statistics overflow */
430 if (op
->frames_filtered
> ULONG_MAX
/100)
431 op
->frames_filtered
= op
->frames_abs
= 0;
433 /* this element is not throttled anymore */
434 data
->flags
&= (BCM_CAN_FLAGS_MASK
|RX_RECV
);
436 head
.opcode
= RX_CHANGED
;
437 head
.flags
= op
->flags
;
438 head
.count
= op
->count
;
439 head
.ival1
= op
->ival1
;
440 head
.ival2
= op
->ival2
;
441 head
.can_id
= op
->can_id
;
444 bcm_send_to_user(op
, &head
, data
, 1);
448 * bcm_rx_update_and_send - process a detected relevant receive content change
449 * 1. update the last received data
450 * 2. send a notification to the user (if possible)
452 static void bcm_rx_update_and_send(struct bcm_op
*op
,
453 struct canfd_frame
*lastdata
,
454 const struct canfd_frame
*rxdata
)
456 memcpy(lastdata
, rxdata
, op
->cfsiz
);
458 /* mark as used and throttled by default */
459 lastdata
->flags
|= (RX_RECV
|RX_THR
);
461 /* throttling mode inactive ? */
463 /* send RX_CHANGED to the user immediately */
464 bcm_rx_changed(op
, lastdata
);
468 /* with active throttling timer we are just done here */
469 if (hrtimer_active(&op
->thrtimer
))
472 /* first reception with enabled throttling mode */
474 goto rx_changed_settime
;
476 /* got a second frame inside a potential throttle period? */
477 if (ktime_us_delta(ktime_get(), op
->kt_lastmsg
) <
478 ktime_to_us(op
->kt_ival2
)) {
479 /* do not send the saved data - only start throttle timer */
480 hrtimer_start(&op
->thrtimer
,
481 ktime_add(op
->kt_lastmsg
, op
->kt_ival2
),
486 /* the gap was that big, that throttling was not needed here */
488 bcm_rx_changed(op
, lastdata
);
489 op
->kt_lastmsg
= ktime_get();
493 * bcm_rx_cmp_to_index - (bit)compares the currently received data to formerly
494 * received data stored in op->last_frames[]
496 static void bcm_rx_cmp_to_index(struct bcm_op
*op
, unsigned int index
,
497 const struct canfd_frame
*rxdata
)
499 struct canfd_frame
*cf
= op
->frames
+ op
->cfsiz
* index
;
500 struct canfd_frame
*lcf
= op
->last_frames
+ op
->cfsiz
* index
;
504 * no one uses the MSBs of flags for comparison,
505 * so we use it here to detect the first time of reception
508 if (!(lcf
->flags
& RX_RECV
)) {
509 /* received data for the first time => send update to user */
510 bcm_rx_update_and_send(op
, lcf
, rxdata
);
514 /* do a real check in CAN frame data section */
515 for (i
= 0; i
< rxdata
->len
; i
+= 8) {
516 if ((get_u64(cf
, i
) & get_u64(rxdata
, i
)) !=
517 (get_u64(cf
, i
) & get_u64(lcf
, i
))) {
518 bcm_rx_update_and_send(op
, lcf
, rxdata
);
523 if (op
->flags
& RX_CHECK_DLC
) {
524 /* do a real check in CAN frame length */
525 if (rxdata
->len
!= lcf
->len
) {
526 bcm_rx_update_and_send(op
, lcf
, rxdata
);
533 * bcm_rx_starttimer - enable timeout monitoring for CAN frame reception
535 static void bcm_rx_starttimer(struct bcm_op
*op
)
537 if (op
->flags
& RX_NO_AUTOTIMER
)
541 hrtimer_start(&op
->timer
, op
->kt_ival1
, HRTIMER_MODE_REL
);
544 static void bcm_rx_timeout_tsklet(unsigned long data
)
546 struct bcm_op
*op
= (struct bcm_op
*)data
;
547 struct bcm_msg_head msg_head
;
549 /* create notification to user */
550 msg_head
.opcode
= RX_TIMEOUT
;
551 msg_head
.flags
= op
->flags
;
552 msg_head
.count
= op
->count
;
553 msg_head
.ival1
= op
->ival1
;
554 msg_head
.ival2
= op
->ival2
;
555 msg_head
.can_id
= op
->can_id
;
556 msg_head
.nframes
= 0;
558 bcm_send_to_user(op
, &msg_head
, NULL
, 0);
562 * bcm_rx_timeout_handler - when the (cyclic) CAN frame reception timed out
564 static enum hrtimer_restart
bcm_rx_timeout_handler(struct hrtimer
*hrtimer
)
566 struct bcm_op
*op
= container_of(hrtimer
, struct bcm_op
, timer
);
568 /* schedule before NET_RX_SOFTIRQ */
569 tasklet_hi_schedule(&op
->tsklet
);
571 /* no restart of the timer is done here! */
573 /* if user wants to be informed, when cyclic CAN-Messages come back */
574 if ((op
->flags
& RX_ANNOUNCE_RESUME
) && op
->last_frames
) {
575 /* clear received CAN frames to indicate 'nothing received' */
576 memset(op
->last_frames
, 0, op
->nframes
* op
->cfsiz
);
579 return HRTIMER_NORESTART
;
583 * bcm_rx_do_flush - helper for bcm_rx_thr_flush
585 static inline int bcm_rx_do_flush(struct bcm_op
*op
, int update
,
588 struct canfd_frame
*lcf
= op
->last_frames
+ op
->cfsiz
* index
;
590 if ((op
->last_frames
) && (lcf
->flags
& RX_THR
)) {
592 bcm_rx_changed(op
, lcf
);
599 * bcm_rx_thr_flush - Check for throttled data and send it to the userspace
601 * update == 0 : just check if throttled data is available (any irq context)
602 * update == 1 : check and send throttled data to userspace (soft_irq context)
604 static int bcm_rx_thr_flush(struct bcm_op
*op
, int update
)
608 if (op
->nframes
> 1) {
611 /* for MUX filter we start at index 1 */
612 for (i
= 1; i
< op
->nframes
; i
++)
613 updated
+= bcm_rx_do_flush(op
, update
, i
);
616 /* for RX_FILTER_ID and simple filter */
617 updated
+= bcm_rx_do_flush(op
, update
, 0);
623 static void bcm_rx_thr_tsklet(unsigned long data
)
625 struct bcm_op
*op
= (struct bcm_op
*)data
;
627 /* push the changed data to the userspace */
628 bcm_rx_thr_flush(op
, 1);
632 * bcm_rx_thr_handler - the time for blocked content updates is over now:
633 * Check for throttled data and send it to the userspace
635 static enum hrtimer_restart
bcm_rx_thr_handler(struct hrtimer
*hrtimer
)
637 struct bcm_op
*op
= container_of(hrtimer
, struct bcm_op
, thrtimer
);
639 tasklet_schedule(&op
->thrtsklet
);
641 if (bcm_rx_thr_flush(op
, 0)) {
642 hrtimer_forward(hrtimer
, ktime_get(), op
->kt_ival2
);
643 return HRTIMER_RESTART
;
645 /* rearm throttle handling */
647 return HRTIMER_NORESTART
;
652 * bcm_rx_handler - handle a CAN frame reception
654 static void bcm_rx_handler(struct sk_buff
*skb
, void *data
)
656 struct bcm_op
*op
= (struct bcm_op
*)data
;
657 const struct canfd_frame
*rxframe
= (struct canfd_frame
*)skb
->data
;
660 if (op
->can_id
!= rxframe
->can_id
)
663 /* make sure to handle the correct frame type (CAN / CAN FD) */
664 if (skb
->len
!= op
->cfsiz
)
667 /* disable timeout */
668 hrtimer_cancel(&op
->timer
);
670 /* save rx timestamp */
671 op
->rx_stamp
= skb
->tstamp
;
672 /* save originator for recvfrom() */
673 op
->rx_ifindex
= skb
->dev
->ifindex
;
674 /* update statistics */
677 if (op
->flags
& RX_RTR_FRAME
) {
678 /* send reply for RTR-request (placed in op->frames[0]) */
683 if (op
->flags
& RX_FILTER_ID
) {
684 /* the easiest case */
685 bcm_rx_update_and_send(op
, op
->last_frames
, rxframe
);
689 if (op
->nframes
== 1) {
690 /* simple compare with index 0 */
691 bcm_rx_cmp_to_index(op
, 0, rxframe
);
695 if (op
->nframes
> 1) {
699 * find the first multiplex mask that fits.
700 * Remark: The MUX-mask is stored in index 0 - but only the
701 * first 64 bits of the frame data[] are relevant (CAN FD)
704 for (i
= 1; i
< op
->nframes
; i
++) {
705 if ((get_u64(op
->frames
, 0) & get_u64(rxframe
, 0)) ==
706 (get_u64(op
->frames
, 0) &
707 get_u64(op
->frames
+ op
->cfsiz
* i
, 0))) {
708 bcm_rx_cmp_to_index(op
, i
, rxframe
);
715 bcm_rx_starttimer(op
);
719 * helpers for bcm_op handling: find & delete bcm [rx|tx] op elements
721 static struct bcm_op
*bcm_find_op(struct list_head
*ops
,
722 struct bcm_msg_head
*mh
, int ifindex
)
726 list_for_each_entry(op
, ops
, list
) {
727 if ((op
->can_id
== mh
->can_id
) && (op
->ifindex
== ifindex
) &&
728 (op
->flags
& CAN_FD_FRAME
) == (mh
->flags
& CAN_FD_FRAME
))
735 static void bcm_remove_op(struct bcm_op
*op
)
737 if (op
->tsklet
.func
) {
738 while (test_bit(TASKLET_STATE_SCHED
, &op
->tsklet
.state
) ||
739 test_bit(TASKLET_STATE_RUN
, &op
->tsklet
.state
) ||
740 hrtimer_active(&op
->timer
)) {
741 hrtimer_cancel(&op
->timer
);
742 tasklet_kill(&op
->tsklet
);
746 if (op
->thrtsklet
.func
) {
747 while (test_bit(TASKLET_STATE_SCHED
, &op
->thrtsklet
.state
) ||
748 test_bit(TASKLET_STATE_RUN
, &op
->thrtsklet
.state
) ||
749 hrtimer_active(&op
->thrtimer
)) {
750 hrtimer_cancel(&op
->thrtimer
);
751 tasklet_kill(&op
->thrtsklet
);
755 if ((op
->frames
) && (op
->frames
!= &op
->sframe
))
758 if ((op
->last_frames
) && (op
->last_frames
!= &op
->last_sframe
))
759 kfree(op
->last_frames
);
764 static void bcm_rx_unreg(struct net_device
*dev
, struct bcm_op
*op
)
766 if (op
->rx_reg_dev
== dev
) {
767 can_rx_unregister(&init_net
, dev
, op
->can_id
,
768 REGMASK(op
->can_id
), bcm_rx_handler
, op
);
770 /* mark as removed subscription */
771 op
->rx_reg_dev
= NULL
;
773 printk(KERN_ERR
"can-bcm: bcm_rx_unreg: registered device "
774 "mismatch %p %p\n", op
->rx_reg_dev
, dev
);
778 * bcm_delete_rx_op - find and remove a rx op (returns number of removed ops)
780 static int bcm_delete_rx_op(struct list_head
*ops
, struct bcm_msg_head
*mh
,
783 struct bcm_op
*op
, *n
;
785 list_for_each_entry_safe(op
, n
, ops
, list
) {
786 if ((op
->can_id
== mh
->can_id
) && (op
->ifindex
== ifindex
) &&
787 (op
->flags
& CAN_FD_FRAME
) == (mh
->flags
& CAN_FD_FRAME
)) {
790 * Don't care if we're bound or not (due to netdev
791 * problems) can_rx_unregister() is always a save
796 * Only remove subscriptions that had not
797 * been removed due to NETDEV_UNREGISTER
800 if (op
->rx_reg_dev
) {
801 struct net_device
*dev
;
803 dev
= dev_get_by_index(&init_net
,
806 bcm_rx_unreg(dev
, op
);
811 can_rx_unregister(&init_net
, NULL
, op
->can_id
,
821 return 0; /* not found */
825 * bcm_delete_tx_op - find and remove a tx op (returns number of removed ops)
827 static int bcm_delete_tx_op(struct list_head
*ops
, struct bcm_msg_head
*mh
,
830 struct bcm_op
*op
, *n
;
832 list_for_each_entry_safe(op
, n
, ops
, list
) {
833 if ((op
->can_id
== mh
->can_id
) && (op
->ifindex
== ifindex
) &&
834 (op
->flags
& CAN_FD_FRAME
) == (mh
->flags
& CAN_FD_FRAME
)) {
841 return 0; /* not found */
845 * bcm_read_op - read out a bcm_op and send it to the user (for bcm_sendmsg)
847 static int bcm_read_op(struct list_head
*ops
, struct bcm_msg_head
*msg_head
,
850 struct bcm_op
*op
= bcm_find_op(ops
, msg_head
, ifindex
);
855 /* put current values into msg_head */
856 msg_head
->flags
= op
->flags
;
857 msg_head
->count
= op
->count
;
858 msg_head
->ival1
= op
->ival1
;
859 msg_head
->ival2
= op
->ival2
;
860 msg_head
->nframes
= op
->nframes
;
862 bcm_send_to_user(op
, msg_head
, op
->frames
, 0);
868 * bcm_tx_setup - create or update a bcm tx op (for bcm_sendmsg)
870 static int bcm_tx_setup(struct bcm_msg_head
*msg_head
, struct msghdr
*msg
,
871 int ifindex
, struct sock
*sk
)
873 struct bcm_sock
*bo
= bcm_sk(sk
);
875 struct canfd_frame
*cf
;
879 /* we need a real device to send frames */
883 /* check nframes boundaries - we need at least one CAN frame */
884 if (msg_head
->nframes
< 1 || msg_head
->nframes
> MAX_NFRAMES
)
887 /* check the given can_id */
888 op
= bcm_find_op(&bo
->tx_ops
, msg_head
, ifindex
);
890 /* update existing BCM operation */
893 * Do we need more space for the CAN frames than currently
894 * allocated? -> This is a _really_ unusual use-case and
895 * therefore (complexity / locking) it is not supported.
897 if (msg_head
->nframes
> op
->nframes
)
900 /* update CAN frames content */
901 for (i
= 0; i
< msg_head
->nframes
; i
++) {
903 cf
= op
->frames
+ op
->cfsiz
* i
;
904 err
= memcpy_from_msg((u8
*)cf
, msg
, op
->cfsiz
);
906 if (op
->flags
& CAN_FD_FRAME
) {
917 if (msg_head
->flags
& TX_CP_CAN_ID
) {
918 /* copy can_id into frame */
919 cf
->can_id
= msg_head
->can_id
;
922 op
->flags
= msg_head
->flags
;
925 /* insert new BCM operation for the given can_id */
927 op
= kzalloc(OPSIZ
, GFP_KERNEL
);
931 op
->can_id
= msg_head
->can_id
;
932 op
->cfsiz
= CFSIZ(msg_head
->flags
);
933 op
->flags
= msg_head
->flags
;
935 /* create array for CAN frames and copy the data */
936 if (msg_head
->nframes
> 1) {
937 op
->frames
= kmalloc(msg_head
->nframes
* op
->cfsiz
,
944 op
->frames
= &op
->sframe
;
946 for (i
= 0; i
< msg_head
->nframes
; i
++) {
948 cf
= op
->frames
+ op
->cfsiz
* i
;
949 err
= memcpy_from_msg((u8
*)cf
, msg
, op
->cfsiz
);
951 if (op
->flags
& CAN_FD_FRAME
) {
960 if (op
->frames
!= &op
->sframe
)
966 if (msg_head
->flags
& TX_CP_CAN_ID
) {
967 /* copy can_id into frame */
968 cf
->can_id
= msg_head
->can_id
;
972 /* tx_ops never compare with previous received messages */
973 op
->last_frames
= NULL
;
975 /* bcm_can_tx / bcm_tx_timeout_handler needs this */
977 op
->ifindex
= ifindex
;
979 /* initialize uninitialized (kzalloc) structure */
980 hrtimer_init(&op
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
981 op
->timer
.function
= bcm_tx_timeout_handler
;
983 /* initialize tasklet for tx countevent notification */
984 tasklet_init(&op
->tsklet
, bcm_tx_timeout_tsklet
,
987 /* currently unused in tx_ops */
988 hrtimer_init(&op
->thrtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
990 /* add this bcm_op to the list of the tx_ops */
991 list_add(&op
->list
, &bo
->tx_ops
);
993 } /* if ((op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex))) */
995 if (op
->nframes
!= msg_head
->nframes
) {
996 op
->nframes
= msg_head
->nframes
;
997 /* start multiple frame transmission with index 0 */
1003 if (op
->flags
& TX_RESET_MULTI_IDX
) {
1004 /* start multiple frame transmission with index 0 */
1008 if (op
->flags
& SETTIMER
) {
1009 /* set timer values */
1010 op
->count
= msg_head
->count
;
1011 op
->ival1
= msg_head
->ival1
;
1012 op
->ival2
= msg_head
->ival2
;
1013 op
->kt_ival1
= bcm_timeval_to_ktime(msg_head
->ival1
);
1014 op
->kt_ival2
= bcm_timeval_to_ktime(msg_head
->ival2
);
1016 /* disable an active timer due to zero values? */
1017 if (!op
->kt_ival1
&& !op
->kt_ival2
)
1018 hrtimer_cancel(&op
->timer
);
1021 if (op
->flags
& STARTTIMER
) {
1022 hrtimer_cancel(&op
->timer
);
1023 /* spec: send CAN frame when starting timer */
1024 op
->flags
|= TX_ANNOUNCE
;
1027 if (op
->flags
& TX_ANNOUNCE
) {
1033 if (op
->flags
& STARTTIMER
)
1034 bcm_tx_start_timer(op
);
1036 return msg_head
->nframes
* op
->cfsiz
+ MHSIZ
;
1040 * bcm_rx_setup - create or update a bcm rx op (for bcm_sendmsg)
1042 static int bcm_rx_setup(struct bcm_msg_head
*msg_head
, struct msghdr
*msg
,
1043 int ifindex
, struct sock
*sk
)
1045 struct bcm_sock
*bo
= bcm_sk(sk
);
1050 if ((msg_head
->flags
& RX_FILTER_ID
) || (!(msg_head
->nframes
))) {
1051 /* be robust against wrong usage ... */
1052 msg_head
->flags
|= RX_FILTER_ID
;
1053 /* ignore trailing garbage */
1054 msg_head
->nframes
= 0;
1057 /* the first element contains the mux-mask => MAX_NFRAMES + 1 */
1058 if (msg_head
->nframes
> MAX_NFRAMES
+ 1)
1061 if ((msg_head
->flags
& RX_RTR_FRAME
) &&
1062 ((msg_head
->nframes
!= 1) ||
1063 (!(msg_head
->can_id
& CAN_RTR_FLAG
))))
1066 /* check the given can_id */
1067 op
= bcm_find_op(&bo
->rx_ops
, msg_head
, ifindex
);
1069 /* update existing BCM operation */
1072 * Do we need more space for the CAN frames than currently
1073 * allocated? -> This is a _really_ unusual use-case and
1074 * therefore (complexity / locking) it is not supported.
1076 if (msg_head
->nframes
> op
->nframes
)
1079 if (msg_head
->nframes
) {
1080 /* update CAN frames content */
1081 err
= memcpy_from_msg(op
->frames
, msg
,
1082 msg_head
->nframes
* op
->cfsiz
);
1086 /* clear last_frames to indicate 'nothing received' */
1087 memset(op
->last_frames
, 0, msg_head
->nframes
* op
->cfsiz
);
1090 op
->nframes
= msg_head
->nframes
;
1091 op
->flags
= msg_head
->flags
;
1093 /* Only an update -> do not call can_rx_register() */
1097 /* insert new BCM operation for the given can_id */
1098 op
= kzalloc(OPSIZ
, GFP_KERNEL
);
1102 op
->can_id
= msg_head
->can_id
;
1103 op
->nframes
= msg_head
->nframes
;
1104 op
->cfsiz
= CFSIZ(msg_head
->flags
);
1105 op
->flags
= msg_head
->flags
;
1107 if (msg_head
->nframes
> 1) {
1108 /* create array for CAN frames and copy the data */
1109 op
->frames
= kmalloc(msg_head
->nframes
* op
->cfsiz
,
1116 /* create and init array for received CAN frames */
1117 op
->last_frames
= kzalloc(msg_head
->nframes
* op
->cfsiz
,
1119 if (!op
->last_frames
) {
1126 op
->frames
= &op
->sframe
;
1127 op
->last_frames
= &op
->last_sframe
;
1130 if (msg_head
->nframes
) {
1131 err
= memcpy_from_msg(op
->frames
, msg
,
1132 msg_head
->nframes
* op
->cfsiz
);
1134 if (op
->frames
!= &op
->sframe
)
1136 if (op
->last_frames
!= &op
->last_sframe
)
1137 kfree(op
->last_frames
);
1143 /* bcm_can_tx / bcm_tx_timeout_handler needs this */
1145 op
->ifindex
= ifindex
;
1147 /* ifindex for timeout events w/o previous frame reception */
1148 op
->rx_ifindex
= ifindex
;
1150 /* initialize uninitialized (kzalloc) structure */
1151 hrtimer_init(&op
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
1152 op
->timer
.function
= bcm_rx_timeout_handler
;
1154 /* initialize tasklet for rx timeout notification */
1155 tasklet_init(&op
->tsklet
, bcm_rx_timeout_tsklet
,
1156 (unsigned long) op
);
1158 hrtimer_init(&op
->thrtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
1159 op
->thrtimer
.function
= bcm_rx_thr_handler
;
1161 /* initialize tasklet for rx throttle handling */
1162 tasklet_init(&op
->thrtsklet
, bcm_rx_thr_tsklet
,
1163 (unsigned long) op
);
1165 /* add this bcm_op to the list of the rx_ops */
1166 list_add(&op
->list
, &bo
->rx_ops
);
1168 /* call can_rx_register() */
1171 } /* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */
1175 if (op
->flags
& RX_RTR_FRAME
) {
1176 struct canfd_frame
*frame0
= op
->frames
;
1178 /* no timers in RTR-mode */
1179 hrtimer_cancel(&op
->thrtimer
);
1180 hrtimer_cancel(&op
->timer
);
1183 * funny feature in RX(!)_SETUP only for RTR-mode:
1184 * copy can_id into frame BUT without RTR-flag to
1185 * prevent a full-load-loopback-test ... ;-]
1187 if ((op
->flags
& TX_CP_CAN_ID
) ||
1188 (frame0
->can_id
== op
->can_id
))
1189 frame0
->can_id
= op
->can_id
& ~CAN_RTR_FLAG
;
1192 if (op
->flags
& SETTIMER
) {
1194 /* set timer value */
1195 op
->ival1
= msg_head
->ival1
;
1196 op
->ival2
= msg_head
->ival2
;
1197 op
->kt_ival1
= bcm_timeval_to_ktime(msg_head
->ival1
);
1198 op
->kt_ival2
= bcm_timeval_to_ktime(msg_head
->ival2
);
1200 /* disable an active timer due to zero value? */
1202 hrtimer_cancel(&op
->timer
);
1205 * In any case cancel the throttle timer, flush
1206 * potentially blocked msgs and reset throttle handling
1209 hrtimer_cancel(&op
->thrtimer
);
1210 bcm_rx_thr_flush(op
, 1);
1213 if ((op
->flags
& STARTTIMER
) && op
->kt_ival1
)
1214 hrtimer_start(&op
->timer
, op
->kt_ival1
,
1218 /* now we can register for can_ids, if we added a new bcm_op */
1219 if (do_rx_register
) {
1221 struct net_device
*dev
;
1223 dev
= dev_get_by_index(&init_net
, ifindex
);
1225 err
= can_rx_register(&init_net
, dev
,
1227 REGMASK(op
->can_id
),
1231 op
->rx_reg_dev
= dev
;
1236 err
= can_rx_register(&init_net
, NULL
, op
->can_id
,
1237 REGMASK(op
->can_id
),
1238 bcm_rx_handler
, op
, "bcm", sk
);
1240 /* this bcm rx op is broken -> remove it */
1241 list_del(&op
->list
);
1247 return msg_head
->nframes
* op
->cfsiz
+ MHSIZ
;
1251 * bcm_tx_send - send a single CAN frame to the CAN interface (for bcm_sendmsg)
1253 static int bcm_tx_send(struct msghdr
*msg
, int ifindex
, struct sock
*sk
,
1256 struct sk_buff
*skb
;
1257 struct net_device
*dev
;
1260 /* we need a real device to send frames */
1264 skb
= alloc_skb(cfsiz
+ sizeof(struct can_skb_priv
), GFP_KERNEL
);
1268 can_skb_reserve(skb
);
1270 err
= memcpy_from_msg(skb_put(skb
, cfsiz
), msg
, cfsiz
);
1276 dev
= dev_get_by_index(&init_net
, ifindex
);
1282 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
1283 can_skb_prv(skb
)->skbcnt
= 0;
1285 can_skb_set_owner(skb
, sk
);
1286 err
= can_send(skb
, 1); /* send with loopback */
1292 return cfsiz
+ MHSIZ
;
1296 * bcm_sendmsg - process BCM commands (opcodes) from the userspace
1298 static int bcm_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
)
1300 struct sock
*sk
= sock
->sk
;
1301 struct bcm_sock
*bo
= bcm_sk(sk
);
1302 int ifindex
= bo
->ifindex
; /* default ifindex for this bcm_op */
1303 struct bcm_msg_head msg_head
;
1305 int ret
; /* read bytes or error codes as return value */
1310 /* check for valid message length from userspace */
1314 /* read message head information */
1315 ret
= memcpy_from_msg((u8
*)&msg_head
, msg
, MHSIZ
);
1319 cfsiz
= CFSIZ(msg_head
.flags
);
1320 if ((size
- MHSIZ
) % cfsiz
)
1323 /* check for alternative ifindex for this bcm_op */
1325 if (!ifindex
&& msg
->msg_name
) {
1326 /* no bound device as default => check msg_name */
1327 DECLARE_SOCKADDR(struct sockaddr_can
*, addr
, msg
->msg_name
);
1329 if (msg
->msg_namelen
< sizeof(*addr
))
1332 if (addr
->can_family
!= AF_CAN
)
1335 /* ifindex from sendto() */
1336 ifindex
= addr
->can_ifindex
;
1339 struct net_device
*dev
;
1341 dev
= dev_get_by_index(&init_net
, ifindex
);
1345 if (dev
->type
!= ARPHRD_CAN
) {
1356 switch (msg_head
.opcode
) {
1359 ret
= bcm_tx_setup(&msg_head
, msg
, ifindex
, sk
);
1363 ret
= bcm_rx_setup(&msg_head
, msg
, ifindex
, sk
);
1367 if (bcm_delete_tx_op(&bo
->tx_ops
, &msg_head
, ifindex
))
1374 if (bcm_delete_rx_op(&bo
->rx_ops
, &msg_head
, ifindex
))
1381 /* reuse msg_head for the reply to TX_READ */
1382 msg_head
.opcode
= TX_STATUS
;
1383 ret
= bcm_read_op(&bo
->tx_ops
, &msg_head
, ifindex
);
1387 /* reuse msg_head for the reply to RX_READ */
1388 msg_head
.opcode
= RX_STATUS
;
1389 ret
= bcm_read_op(&bo
->rx_ops
, &msg_head
, ifindex
);
1393 /* we need exactly one CAN frame behind the msg head */
1394 if ((msg_head
.nframes
!= 1) || (size
!= cfsiz
+ MHSIZ
))
1397 ret
= bcm_tx_send(msg
, ifindex
, sk
, cfsiz
);
1411 * notification handler for netdevice status changes
1413 static int bcm_notifier(struct notifier_block
*nb
, unsigned long msg
,
1416 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1417 struct bcm_sock
*bo
= container_of(nb
, struct bcm_sock
, notifier
);
1418 struct sock
*sk
= &bo
->sk
;
1420 int notify_enodev
= 0;
1422 if (!net_eq(dev_net(dev
), &init_net
))
1425 if (dev
->type
!= ARPHRD_CAN
)
1430 case NETDEV_UNREGISTER
:
1433 /* remove device specific receive entries */
1434 list_for_each_entry(op
, &bo
->rx_ops
, list
)
1435 if (op
->rx_reg_dev
== dev
)
1436 bcm_rx_unreg(dev
, op
);
1438 /* remove device reference, if this is our bound device */
1439 if (bo
->bound
&& bo
->ifindex
== dev
->ifindex
) {
1447 if (notify_enodev
) {
1448 sk
->sk_err
= ENODEV
;
1449 if (!sock_flag(sk
, SOCK_DEAD
))
1450 sk
->sk_error_report(sk
);
1455 if (bo
->bound
&& bo
->ifindex
== dev
->ifindex
) {
1456 sk
->sk_err
= ENETDOWN
;
1457 if (!sock_flag(sk
, SOCK_DEAD
))
1458 sk
->sk_error_report(sk
);
1466 * initial settings for all BCM sockets to be set at socket creation time
1468 static int bcm_init(struct sock
*sk
)
1470 struct bcm_sock
*bo
= bcm_sk(sk
);
1474 bo
->dropped_usr_msgs
= 0;
1475 bo
->bcm_proc_read
= NULL
;
1477 INIT_LIST_HEAD(&bo
->tx_ops
);
1478 INIT_LIST_HEAD(&bo
->rx_ops
);
1481 bo
->notifier
.notifier_call
= bcm_notifier
;
1483 register_netdevice_notifier(&bo
->notifier
);
1489 * standard socket functions
1491 static int bcm_release(struct socket
*sock
)
1493 struct sock
*sk
= sock
->sk
;
1494 struct bcm_sock
*bo
;
1495 struct bcm_op
*op
, *next
;
1502 /* remove bcm_ops, timer, rx_unregister(), etc. */
1504 unregister_netdevice_notifier(&bo
->notifier
);
1508 list_for_each_entry_safe(op
, next
, &bo
->tx_ops
, list
)
1511 list_for_each_entry_safe(op
, next
, &bo
->rx_ops
, list
) {
1513 * Don't care if we're bound or not (due to netdev problems)
1514 * can_rx_unregister() is always a save thing to do here.
1518 * Only remove subscriptions that had not
1519 * been removed due to NETDEV_UNREGISTER
1522 if (op
->rx_reg_dev
) {
1523 struct net_device
*dev
;
1525 dev
= dev_get_by_index(&init_net
, op
->ifindex
);
1527 bcm_rx_unreg(dev
, op
);
1532 can_rx_unregister(&init_net
, NULL
, op
->can_id
,
1533 REGMASK(op
->can_id
),
1534 bcm_rx_handler
, op
);
1539 /* remove procfs entry */
1540 if (proc_dir
&& bo
->bcm_proc_read
)
1541 remove_proc_entry(bo
->procname
, proc_dir
);
1543 /* remove device reference */
1558 static int bcm_connect(struct socket
*sock
, struct sockaddr
*uaddr
, int len
,
1561 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1562 struct sock
*sk
= sock
->sk
;
1563 struct bcm_sock
*bo
= bcm_sk(sk
);
1566 if (len
< sizeof(*addr
))
1576 /* bind a device to this socket */
1577 if (addr
->can_ifindex
) {
1578 struct net_device
*dev
;
1580 dev
= dev_get_by_index(&init_net
, addr
->can_ifindex
);
1585 if (dev
->type
!= ARPHRD_CAN
) {
1591 bo
->ifindex
= dev
->ifindex
;
1595 /* no interface reference for ifindex = 0 ('any' CAN device) */
1600 /* unique socket address as filename */
1601 sprintf(bo
->procname
, "%lu", sock_i_ino(sk
));
1602 bo
->bcm_proc_read
= proc_create_data(bo
->procname
, 0644,
1604 &bcm_proc_fops
, sk
);
1605 if (!bo
->bcm_proc_read
) {
1619 static int bcm_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1622 struct sock
*sk
= sock
->sk
;
1623 struct sk_buff
*skb
;
1628 noblock
= flags
& MSG_DONTWAIT
;
1629 flags
&= ~MSG_DONTWAIT
;
1630 skb
= skb_recv_datagram(sk
, flags
, noblock
, &error
);
1634 if (skb
->len
< size
)
1637 err
= memcpy_to_msg(msg
, skb
->data
, size
);
1639 skb_free_datagram(sk
, skb
);
1643 sock_recv_ts_and_drops(msg
, sk
, skb
);
1645 if (msg
->msg_name
) {
1646 __sockaddr_check_size(sizeof(struct sockaddr_can
));
1647 msg
->msg_namelen
= sizeof(struct sockaddr_can
);
1648 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
1651 skb_free_datagram(sk
, skb
);
1656 static const struct proto_ops bcm_ops
= {
1658 .release
= bcm_release
,
1659 .bind
= sock_no_bind
,
1660 .connect
= bcm_connect
,
1661 .socketpair
= sock_no_socketpair
,
1662 .accept
= sock_no_accept
,
1663 .getname
= sock_no_getname
,
1664 .poll
= datagram_poll
,
1665 .ioctl
= can_ioctl
, /* use can_ioctl() from af_can.c */
1666 .listen
= sock_no_listen
,
1667 .shutdown
= sock_no_shutdown
,
1668 .setsockopt
= sock_no_setsockopt
,
1669 .getsockopt
= sock_no_getsockopt
,
1670 .sendmsg
= bcm_sendmsg
,
1671 .recvmsg
= bcm_recvmsg
,
1672 .mmap
= sock_no_mmap
,
1673 .sendpage
= sock_no_sendpage
,
1676 static struct proto bcm_proto __read_mostly
= {
1678 .owner
= THIS_MODULE
,
1679 .obj_size
= sizeof(struct bcm_sock
),
1683 static const struct can_proto bcm_can_proto
= {
1685 .protocol
= CAN_BCM
,
1690 static int __init
bcm_module_init(void)
1694 pr_info("can: broadcast manager protocol (rev " CAN_BCM_VERSION
" t)\n");
1696 err
= can_proto_register(&bcm_can_proto
);
1698 printk(KERN_ERR
"can: registration of bcm protocol failed\n");
1702 /* create /proc/net/can-bcm directory */
1703 proc_dir
= proc_mkdir("can-bcm", init_net
.proc_net
);
1707 static void __exit
bcm_module_exit(void)
1709 can_proto_unregister(&bcm_can_proto
);
1712 remove_proc_entry("can-bcm", init_net
.proc_net
);
1715 module_init(bcm_module_init
);
1716 module_exit(bcm_module_exit
);