net/can/j1939/j1939-priv.h

   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_ */