1 /* SPDX-License-Identifier: GPL-2.0 */
2 // Copyright (c) 2010-2011 EIA Electronics,
3 // Kurt Van Dijck <kurt.van.dijck@eia.be>
4 // Copyright (c) 2017-2019 Pengutronix,
5 // Marc Kleine-Budde <kernel@pengutronix.de>
6 // Copyright (c) 2017-2019 Pengutronix,
7 // Oleksij Rempel <kernel@pengutronix.de>
8
9 #ifndef _J1939_PRIV_H_
10 #define _J1939_PRIV_H_
11
12 #include <linux/can/j1939.h>
13 #include <net/sock.h>
14
15 /* Timeout to receive the abort signal over loop back. In case CAN
16 * bus is open, the timeout should be triggered.
17 */
18 #define J1939_XTP_ABORT_TIMEOUT_MS 500
19 #define J1939_SIMPLE_ECHO_TIMEOUT_MS (10 * 1000)
20
21 struct j1939_session;
22 enum j1939_sk_errqueue_type {
23 J1939_ERRQUEUE_ACK,
24 J1939_ERRQUEUE_SCHED,
25 J1939_ERRQUEUE_ABORT,
26 };
27
28 /* j1939 devices */
29 struct j1939_ecu {
30 struct list_head list;
31 name_t name;
32 u8 addr;
33
34 /* indicates that this ecu successfully claimed @sa as its address */
35 struct hrtimer ac_timer;
36 struct kref kref;
37 struct j1939_priv *priv;
38
39 /* count users, to help transport protocol decide for interaction */
40 int nusers;
41 };
42
43 struct j1939_priv {
44 struct list_head ecus;
45 /* local list entry in priv
46 * These allow irq (& softirq) context lookups on j1939 devices
47 * This approach (separate lists) is done as the other 2 alternatives
48 * are not easier or even wrong
49 * 1) using the pure kobject methods involves mutexes, which are not
50 * allowed in irq context.
51 * 2) duplicating data structures would require a lot of synchronization
52 * code
53 * usage:
54 */
55
56 /* segments need a lock to protect the above list */
57 rwlock_t lock;
58
59 struct net_device *ndev;
60
61 /* list of 256 ecu ptrs, that cache the claimed addresses.
62 * also protected by the above lock
63 */
64 struct j1939_addr_ent {
65 struct j1939_ecu *ecu;
66 /* count users, to help transport protocol */
67 int nusers;
68 } ents[256];
69
70 struct kref kref;
71
72 /* List of active sessions to prevent start of conflicting
73 * one.
74 *
75 * Do not start two sessions of same type, addresses and
76 * direction.
77 */
78 struct list_head active_session_list;
79
80 /* protects active_session_list */
81 spinlock_t active_session_list_lock;
82
83 unsigned int tp_max_packet_size;
84
85 /* lock for j1939_socks list */
86 spinlock_t j1939_socks_lock;
87 struct list_head j1939_socks;
88
89 struct kref rx_kref;
90 };
91
92 void j1939_ecu_put(struct j1939_ecu *ecu);
93
94 /* keep the cache of what is local */
95 int j1939_local_ecu_get(struct j1939_priv *priv, name_t name, u8 sa);
96 void j1939_local_ecu_put(struct j1939_priv *priv, name_t name, u8 sa);
97
j1939_address_is_unicast(u8 addr)98 static inline bool j1939_address_is_unicast(u8 addr)
99 {
100 return addr <= J1939_MAX_UNICAST_ADDR;
101 }
102
j1939_address_is_idle(u8 addr)103 static inline bool j1939_address_is_idle(u8 addr)
104 {
105 return addr == J1939_IDLE_ADDR;
106 }
107
j1939_address_is_valid(u8 addr)108 static inline bool j1939_address_is_valid(u8 addr)
109 {
110 return addr != J1939_NO_ADDR;
111 }
112
j1939_pgn_is_pdu1(pgn_t pgn)113 static inline bool j1939_pgn_is_pdu1(pgn_t pgn)
114 {
115 /* ignore dp & res bits for this */
116 return (pgn & 0xff00) < 0xf000;
117 }
118
119 /* utility to correctly unmap an ECU */
120 void j1939_ecu_unmap_locked(struct j1939_ecu *ecu);
121 void j1939_ecu_unmap(struct j1939_ecu *ecu);
122
123 u8 j1939_name_to_addr(struct j1939_priv *priv, name_t name);
124 struct j1939_ecu *j1939_ecu_find_by_addr_locked(struct j1939_priv *priv,
125 u8 addr);
126 struct j1939_ecu *j1939_ecu_get_by_addr(struct j1939_priv *priv, u8 addr);
127 struct j1939_ecu *j1939_ecu_get_by_addr_locked(struct j1939_priv *priv,
128 u8 addr);
129 struct j1939_ecu *j1939_ecu_get_by_name(struct j1939_priv *priv, name_t name);
130 struct j1939_ecu *j1939_ecu_get_by_name_locked(struct j1939_priv *priv,
131 name_t name);
132
133 enum j1939_transfer_type {
134 J1939_TP,
135 J1939_ETP,
136 J1939_SIMPLE,
137 };
138
139 struct j1939_addr {
140 name_t src_name;
141 name_t dst_name;
142 pgn_t pgn;
143
144 u8 sa;
145 u8 da;
146
147 u8 type;
148 };
149
150 /* control buffer of the sk_buff */
151 struct j1939_sk_buff_cb {
152 /* Offset in bytes within one ETP session */
153 u32 offset;
154
155 /* for tx, MSG_SYN will be used to sync on sockets */
156 u32 msg_flags;
157 u32 tskey;
158
159 struct j1939_addr addr;
160
161 /* Flags for quick lookups during skb processing.
162 * These are set in the receive path only.
163 */
164 #define J1939_ECU_LOCAL_SRC BIT(0)
165 #define J1939_ECU_LOCAL_DST BIT(1)
166 u8 flags;
167
168 priority_t priority;
169 };
170
171 static inline
j1939_skb_to_cb(const struct sk_buff * skb)172 struct j1939_sk_buff_cb *j1939_skb_to_cb(const struct sk_buff *skb)
173 {
174 BUILD_BUG_ON(sizeof(struct j1939_sk_buff_cb) > sizeof(skb->cb));
175
176 return (struct j1939_sk_buff_cb *)skb->cb;
177 }
178
179 int j1939_send_one(struct j1939_priv *priv, struct sk_buff *skb);
180 void j1939_sk_recv(struct j1939_priv *priv, struct sk_buff *skb);
181 bool j1939_sk_recv_match(struct j1939_priv *priv,
182 struct j1939_sk_buff_cb *skcb);
183 void j1939_sk_send_loop_abort(struct sock *sk, int err);
184 void j1939_sk_errqueue(struct j1939_session *session,
185 enum j1939_sk_errqueue_type type);
186 void j1939_sk_queue_activate_next(struct j1939_session *session);
187
188 /* stack entries */
189 struct j1939_session *j1939_tp_send(struct j1939_priv *priv,
190 struct sk_buff *skb, size_t size);
191 int j1939_tp_recv(struct j1939_priv *priv, struct sk_buff *skb);
192 int j1939_ac_fixup(struct j1939_priv *priv, struct sk_buff *skb);
193 void j1939_ac_recv(struct j1939_priv *priv, struct sk_buff *skb);
194 void j1939_simple_recv(struct j1939_priv *priv, struct sk_buff *skb);
195
196 /* network management */
197 struct j1939_ecu *j1939_ecu_create_locked(struct j1939_priv *priv, name_t name);
198
199 void j1939_ecu_timer_start(struct j1939_ecu *ecu);
200 void j1939_ecu_timer_cancel(struct j1939_ecu *ecu);
201 void j1939_ecu_unmap_all(struct j1939_priv *priv);
202
203 struct j1939_priv *j1939_netdev_start(struct net_device *ndev);
204 void j1939_netdev_stop(struct j1939_priv *priv);
205
206 void j1939_priv_put(struct j1939_priv *priv);
207 void j1939_priv_get(struct j1939_priv *priv);
208
209 /* notify/alert all j1939 sockets bound to ifindex */
210 void j1939_sk_netdev_event_netdown(struct j1939_priv *priv);
211 int j1939_cancel_active_session(struct j1939_priv *priv, struct sock *sk);
212 void j1939_tp_init(struct j1939_priv *priv);
213
214 /* decrement pending skb for a j1939 socket */
215 void j1939_sock_pending_del(struct sock *sk);
216
217 enum j1939_session_state {
218 J1939_SESSION_NEW,
219 J1939_SESSION_ACTIVE,
220 /* waiting for abort signal on the bus */
221 J1939_SESSION_WAITING_ABORT,
222 J1939_SESSION_ACTIVE_MAX,
223 J1939_SESSION_DONE,
224 };
225
226 struct j1939_session {
227 struct j1939_priv *priv;
228 struct list_head active_session_list_entry;
229 struct list_head sk_session_queue_entry;
230 struct kref kref;
231 struct sock *sk;
232
233 /* ifindex, src, dst, pgn define the session block
234 * the are _never_ modified after insertion in the list
235 * this decreases locking problems a _lot_
236 */
237 struct j1939_sk_buff_cb skcb;
238 struct sk_buff_head skb_queue;
239
240 /* all tx related stuff (last_txcmd, pkt.tx)
241 * is protected (modified only) with the txtimer hrtimer
242 * 'total' & 'block' are never changed,
243 * last_cmd, last & block are protected by ->lock
244 * this means that the tx may run after cts is received that should
245 * have stopped tx, but this time discrepancy is never avoided anyhow
246 */
247 u8 last_cmd, last_txcmd;
248 bool transmission;
249 bool extd;
250 /* Total message size, number of bytes */
251 unsigned int total_message_size;
252 /* Total number of bytes queue from socket to the session */
253 unsigned int total_queued_size;
254 unsigned int tx_retry;
255
256 int err;
257 u32 tskey;
258 enum j1939_session_state state;
259
260 /* Packets counters for a (extended) transfer session. The packet is
261 * maximal of 7 bytes.
262 */
263 struct {
264 /* total - total number of packets for this session */
265 unsigned int total;
266 /* last - last packet of a transfer block after which
267 * responder should send ETP.CM_CTS and originator
268 * ETP.CM_DPO
269 */
270 unsigned int last;
271 /* tx - number of packets send by originator node.
272 * this counter can be set back if responder node
273 * didn't received all packets send by originator.
274 */
275 unsigned int tx;
276 unsigned int tx_acked;
277 /* rx - number of packets received */
278 unsigned int rx;
279 /* block - amount of packets expected in one block */
280 unsigned int block;
281 /* dpo - ETP.CM_DPO, Data Packet Offset */
282 unsigned int dpo;
283 } pkt;
284 struct hrtimer txtimer, rxtimer;
285 };
286
287 struct j1939_sock {
288 struct sock sk; /* must be first to skip with memset */
289 struct j1939_priv *priv;
290 struct list_head list;
291
292 #define J1939_SOCK_BOUND BIT(0)
293 #define J1939_SOCK_CONNECTED BIT(1)
294 #define J1939_SOCK_PROMISC BIT(2)
295 #define J1939_SOCK_ERRQUEUE BIT(3)
296 int state;
297
298 int ifindex;
299 struct j1939_addr addr;
300 struct j1939_filter *filters;
301 int nfilters;
302 pgn_t pgn_rx_filter;
303
304 /* j1939 may emit equal PGN (!= equal CAN-id's) out of order
305 * when transport protocol comes in.
306 * To allow emitting in order, keep a 'pending' nr. of packets
307 */
308 atomic_t skb_pending;
309 wait_queue_head_t waitq;
310
311 /* lock for the sk_session_queue list */
312 spinlock_t sk_session_queue_lock;
313 struct list_head sk_session_queue;
314 };
315
j1939_sk(const struct sock * sk)316 static inline struct j1939_sock *j1939_sk(const struct sock *sk)
317 {
318 return container_of(sk, struct j1939_sock, sk);
319 }
320
321 void j1939_session_get(struct j1939_session *session);
322 void j1939_session_put(struct j1939_session *session);
323 void j1939_session_skb_queue(struct j1939_session *session,
324 struct sk_buff *skb);
325 int j1939_session_activate(struct j1939_session *session);
326 void j1939_tp_schedule_txtimer(struct j1939_session *session, int msec);
327 void j1939_session_timers_cancel(struct j1939_session *session);
328
329 #define J1939_MAX_TP_PACKET_SIZE (7 * 0xff)
330 #define J1939_MAX_ETP_PACKET_SIZE (7 * 0x00ffffff)
331
332 #define J1939_REGULAR 0
333 #define J1939_EXTENDED 1
334
335 /* CAN protocol */
336 extern const struct can_proto j1939_can_proto;
337
338 #endif /* _J1939_PRIV_H_ */
339
