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