root/net/can/j1939/j1939-priv.h

INCLUDED FROM

DEFINITIONS

1. j1939_address_is_unicast
2. j1939_address_is_idle
3. j1939_address_is_valid
4. j1939_pgn_is_pdu1
5. j1939_skb_to_cb
6. j1939_sk

   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 
  98 static inline bool j1939_address_is_unicast(u8 addr)
  99 {
 100         return addr <= J1939_MAX_UNICAST_ADDR;
 101 }
 102 
 103 static inline bool j1939_address_is_idle(u8 addr)
 104 {
 105         return addr == J1939_IDLE_ADDR;
 106 }
 107 
 108 static inline bool j1939_address_is_valid(u8 addr)
 109 {
 110         return addr != J1939_NO_ADDR;
 111 }
 112 
 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
 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 
 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_ */