1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2010-2011 EIA Electronics,
3 // Pieter Beyens <pieter.beyens@eia.be>
4 // Copyright (c) 2010-2011 EIA Electronics,
5 // Kurt Van Dijck <kurt.van.dijck@eia.be>
6 // Copyright (c) 2018 Protonic,
7 // Robin van der Gracht <robin@protonic.nl>
8 // Copyright (c) 2017-2019 Pengutronix,
9 // Marc Kleine-Budde <kernel@pengutronix.de>
10 // Copyright (c) 2017-2019 Pengutronix,
11 // Oleksij Rempel <kernel@pengutronix.de>
13 /* Core of can-j1939 that links j1939 to CAN. */
15 #include <linux/can/can-ml.h>
16 #include <linux/can/core.h>
17 #include <linux/can/skb.h>
18 #include <linux/if_arp.h>
19 #include <linux/module.h>
21 #include "j1939-priv.h"
23 MODULE_DESCRIPTION("PF_CAN SAE J1939");
24 MODULE_LICENSE("GPL v2");
25 MODULE_AUTHOR("EIA Electronics (Kurt Van Dijck & Pieter Beyens)");
26 MODULE_ALIAS("can-proto-" __stringify(CAN_J1939
));
28 /* LOWLEVEL CAN interface */
30 /* CAN_HDR: #bytes before can_frame data part */
31 #define J1939_CAN_HDR (offsetof(struct can_frame, data))
33 /* CAN_FTR: #bytes beyond data part */
34 #define J1939_CAN_FTR (sizeof(struct can_frame) - J1939_CAN_HDR - \
35 sizeof(((struct can_frame *)0)->data))
38 static void j1939_can_recv(struct sk_buff
*iskb
, void *data
)
40 struct j1939_priv
*priv
= data
;
42 struct j1939_sk_buff_cb
*skcb
, *iskcb
;
45 /* create a copy of the skb
46 * j1939 only delivers the real data bytes,
47 * the header goes into sockaddr.
48 * j1939 may not touch the incoming skb in such way
50 skb
= skb_clone(iskb
, GFP_ATOMIC
);
55 can_skb_set_owner(skb
, iskb
->sk
);
57 /* get a pointer to the header of the skb
58 * the skb payload (pointer) is moved, so that the next skb_data
59 * returns the actual payload
61 cf
= (void *)skb
->data
;
62 skb_pull(skb
, J1939_CAN_HDR
);
64 /* fix length, set to dlc, with 8 maximum */
65 skb_trim(skb
, min_t(uint8_t, cf
->len
, 8));
68 skcb
= j1939_skb_to_cb(skb
);
69 memset(skcb
, 0, sizeof(*skcb
));
71 iskcb
= j1939_skb_to_cb(iskb
);
72 skcb
->tskey
= iskcb
->tskey
;
73 skcb
->priority
= (cf
->can_id
>> 26) & 0x7;
74 skcb
->addr
.sa
= cf
->can_id
;
75 skcb
->addr
.pgn
= (cf
->can_id
>> 8) & J1939_PGN_MAX
;
76 /* set default message type */
77 skcb
->addr
.type
= J1939_TP
;
78 if (j1939_pgn_is_pdu1(skcb
->addr
.pgn
)) {
79 /* Type 1: with destination address */
80 skcb
->addr
.da
= skcb
->addr
.pgn
;
81 /* normalize pgn: strip dst address */
82 skcb
->addr
.pgn
&= 0x3ff00;
84 /* set broadcast address */
85 skcb
->addr
.da
= J1939_NO_ADDR
;
88 /* update localflags */
89 read_lock_bh(&priv
->lock
);
90 if (j1939_address_is_unicast(skcb
->addr
.sa
) &&
91 priv
->ents
[skcb
->addr
.sa
].nusers
)
92 skcb
->flags
|= J1939_ECU_LOCAL_SRC
;
93 if (j1939_address_is_unicast(skcb
->addr
.da
) &&
94 priv
->ents
[skcb
->addr
.da
].nusers
)
95 skcb
->flags
|= J1939_ECU_LOCAL_DST
;
96 read_unlock_bh(&priv
->lock
);
98 /* deliver into the j1939 stack ... */
99 j1939_ac_recv(priv
, skb
);
101 if (j1939_tp_recv(priv
, skb
))
102 /* this means the transport layer processed the message */
105 j1939_simple_recv(priv
, skb
);
106 j1939_sk_recv(priv
, skb
);
108 j1939_priv_put(priv
);
112 /* NETDEV MANAGEMENT */
114 /* values for can_rx_(un)register */
115 #define J1939_CAN_ID CAN_EFF_FLAG
116 #define J1939_CAN_MASK (CAN_EFF_FLAG | CAN_RTR_FLAG)
118 static DEFINE_SPINLOCK(j1939_netdev_lock
);
120 static struct j1939_priv
*j1939_priv_create(struct net_device
*ndev
)
122 struct j1939_priv
*priv
;
124 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
128 rwlock_init(&priv
->lock
);
129 INIT_LIST_HEAD(&priv
->ecus
);
131 kref_init(&priv
->kref
);
132 kref_init(&priv
->rx_kref
);
135 netdev_dbg(priv
->ndev
, "%s : 0x%p\n", __func__
, priv
);
140 static inline void j1939_priv_set(struct net_device
*ndev
,
141 struct j1939_priv
*priv
)
143 struct can_ml_priv
*can_ml
= can_get_ml_priv(ndev
);
145 can_ml
->j1939_priv
= priv
;
148 static void __j1939_priv_release(struct kref
*kref
)
150 struct j1939_priv
*priv
= container_of(kref
, struct j1939_priv
, kref
);
151 struct net_device
*ndev
= priv
->ndev
;
153 netdev_dbg(priv
->ndev
, "%s: 0x%p\n", __func__
, priv
);
155 WARN_ON_ONCE(!list_empty(&priv
->active_session_list
));
156 WARN_ON_ONCE(!list_empty(&priv
->ecus
));
157 WARN_ON_ONCE(!list_empty(&priv
->j1939_socks
));
163 void j1939_priv_put(struct j1939_priv
*priv
)
165 kref_put(&priv
->kref
, __j1939_priv_release
);
168 void j1939_priv_get(struct j1939_priv
*priv
)
170 kref_get(&priv
->kref
);
173 static int j1939_can_rx_register(struct j1939_priv
*priv
)
175 struct net_device
*ndev
= priv
->ndev
;
178 j1939_priv_get(priv
);
179 ret
= can_rx_register(dev_net(ndev
), ndev
, J1939_CAN_ID
, J1939_CAN_MASK
,
180 j1939_can_recv
, priv
, "j1939", NULL
);
182 j1939_priv_put(priv
);
189 static void j1939_can_rx_unregister(struct j1939_priv
*priv
)
191 struct net_device
*ndev
= priv
->ndev
;
193 can_rx_unregister(dev_net(ndev
), ndev
, J1939_CAN_ID
, J1939_CAN_MASK
,
194 j1939_can_recv
, priv
);
196 /* The last reference of priv is dropped by the RCU deferred
197 * j1939_sk_sock_destruct() of the last socket, so we can
198 * safely drop this reference here.
200 j1939_priv_put(priv
);
203 static void __j1939_rx_release(struct kref
*kref
)
204 __releases(&j1939_netdev_lock
)
206 struct j1939_priv
*priv
= container_of(kref
, struct j1939_priv
,
209 j1939_can_rx_unregister(priv
);
210 j1939_ecu_unmap_all(priv
);
211 j1939_priv_set(priv
->ndev
, NULL
);
212 spin_unlock(&j1939_netdev_lock
);
215 /* get pointer to priv without increasing ref counter */
216 static inline struct j1939_priv
*j1939_ndev_to_priv(struct net_device
*ndev
)
218 struct can_ml_priv
*can_ml
= can_get_ml_priv(ndev
);
220 return can_ml
->j1939_priv
;
223 static struct j1939_priv
*j1939_priv_get_by_ndev_locked(struct net_device
*ndev
)
225 struct j1939_priv
*priv
;
227 lockdep_assert_held(&j1939_netdev_lock
);
229 priv
= j1939_ndev_to_priv(ndev
);
231 j1939_priv_get(priv
);
236 static struct j1939_priv
*j1939_priv_get_by_ndev(struct net_device
*ndev
)
238 struct j1939_priv
*priv
;
240 spin_lock(&j1939_netdev_lock
);
241 priv
= j1939_priv_get_by_ndev_locked(ndev
);
242 spin_unlock(&j1939_netdev_lock
);
247 struct j1939_priv
*j1939_netdev_start(struct net_device
*ndev
)
249 struct j1939_priv
*priv
, *priv_new
;
252 spin_lock(&j1939_netdev_lock
);
253 priv
= j1939_priv_get_by_ndev_locked(ndev
);
255 kref_get(&priv
->rx_kref
);
256 spin_unlock(&j1939_netdev_lock
);
259 spin_unlock(&j1939_netdev_lock
);
261 priv
= j1939_priv_create(ndev
);
263 return ERR_PTR(-ENOMEM
);
266 spin_lock_init(&priv
->j1939_socks_lock
);
267 INIT_LIST_HEAD(&priv
->j1939_socks
);
269 spin_lock(&j1939_netdev_lock
);
270 priv_new
= j1939_priv_get_by_ndev_locked(ndev
);
272 /* Someone was faster than us, use their priv and roll
275 kref_get(&priv_new
->rx_kref
);
276 spin_unlock(&j1939_netdev_lock
);
281 j1939_priv_set(ndev
, priv
);
282 spin_unlock(&j1939_netdev_lock
);
284 ret
= j1939_can_rx_register(priv
);
291 j1939_priv_set(ndev
, NULL
);
298 void j1939_netdev_stop(struct j1939_priv
*priv
)
300 kref_put_lock(&priv
->rx_kref
, __j1939_rx_release
, &j1939_netdev_lock
);
301 j1939_priv_put(priv
);
304 int j1939_send_one(struct j1939_priv
*priv
, struct sk_buff
*skb
)
308 struct j1939_sk_buff_cb
*skcb
= j1939_skb_to_cb(skb
);
309 struct can_frame
*cf
;
311 /* apply sanity checks */
312 if (j1939_pgn_is_pdu1(skcb
->addr
.pgn
))
313 skcb
->addr
.pgn
&= J1939_PGN_PDU1_MAX
;
315 skcb
->addr
.pgn
&= J1939_PGN_MAX
;
317 if (skcb
->priority
> 7)
320 ret
= j1939_ac_fixup(priv
, skb
);
325 /* re-claim the CAN_HDR from the SKB */
326 cf
= skb_push(skb
, J1939_CAN_HDR
);
328 /* make it a full can frame again */
329 skb_put(skb
, J1939_CAN_FTR
+ (8 - dlc
));
331 canid
= CAN_EFF_FLAG
|
332 (skcb
->priority
<< 26) |
333 (skcb
->addr
.pgn
<< 8) |
335 if (j1939_pgn_is_pdu1(skcb
->addr
.pgn
))
336 canid
|= skcb
->addr
.da
<< 8;
341 return can_send(skb
, 1);
348 static int j1939_netdev_notify(struct notifier_block
*nb
,
349 unsigned long msg
, void *data
)
351 struct net_device
*ndev
= netdev_notifier_info_to_dev(data
);
352 struct can_ml_priv
*can_ml
= can_get_ml_priv(ndev
);
353 struct j1939_priv
*priv
;
358 priv
= j1939_priv_get_by_ndev(ndev
);
364 j1939_cancel_active_session(priv
, NULL
);
365 j1939_sk_netdev_event_netdown(priv
);
366 j1939_ecu_unmap_all(priv
);
370 j1939_priv_put(priv
);
376 static struct notifier_block j1939_netdev_notifier
= {
377 .notifier_call
= j1939_netdev_notify
,
380 /* MODULE interface */
381 static __init
int j1939_module_init(void)
385 pr_info("can: SAE J1939\n");
387 ret
= register_netdevice_notifier(&j1939_netdev_notifier
);
391 ret
= can_proto_register(&j1939_can_proto
);
393 pr_err("can: registration of j1939 protocol failed\n");
400 unregister_netdevice_notifier(&j1939_netdev_notifier
);
405 static __exit
void j1939_module_exit(void)
407 can_proto_unregister(&j1939_can_proto
);
409 unregister_netdevice_notifier(&j1939_netdev_notifier
);
412 module_init(j1939_module_init
);
413 module_exit(j1939_module_exit
);