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/* bus for j1939 remote devices 10 * Since rtnetlink, no real bus is used. 11 */ 12 13#include <net/sock.h> 14 15#include "j1939-priv.h" 16 17static void __j1939_ecu_release(struct kref *kref) 18{ 19 struct j1939_ecu *ecu = container_of(kref, struct j1939_ecu, kref); 20 struct j1939_priv *priv = ecu->priv; 21 22 list_del(&ecu->list); 23 kfree(ecu); 24 j1939_priv_put(priv); 25} 26 27void j1939_ecu_put(struct j1939_ecu *ecu) 28{ 29 kref_put(&ecu->kref, __j1939_ecu_release); 30} 31 32static void j1939_ecu_get(struct j1939_ecu *ecu) 33{ 34 kref_get(&ecu->kref); 35} 36 37static bool j1939_ecu_is_mapped_locked(struct j1939_ecu *ecu) 38{ 39 struct j1939_priv *priv = ecu->priv; 40 41 lockdep_assert_held(&priv->lock); 42 43 return j1939_ecu_find_by_addr_locked(priv, ecu->addr) == ecu; 44} 45 46/* ECU device interface */ 47/* map ECU to a bus address space */ 48static void j1939_ecu_map_locked(struct j1939_ecu *ecu) 49{ 50 struct j1939_priv *priv = ecu->priv; 51 struct j1939_addr_ent *ent; 52 53 lockdep_assert_held(&priv->lock); 54 55 if (!j1939_address_is_unicast(ecu->addr)) 56 return; 57 58 ent = &priv->ents[ecu->addr]; 59 60 if (ent->ecu) { 61 netdev_warn(priv->ndev, "Trying to map already mapped ECU, addr: 0x%02x, name: 0x%016llx. Skip it.\n", 62 ecu->addr, ecu->name); 63 return; 64 } 65 66 j1939_ecu_get(ecu); 67 ent->ecu = ecu; 68 ent->nusers += ecu->nusers; 69} 70 71/* unmap ECU from a bus address space */ 72void j1939_ecu_unmap_locked(struct j1939_ecu *ecu) 73{ 74 struct j1939_priv *priv = ecu->priv; 75 struct j1939_addr_ent *ent; 76 77 lockdep_assert_held(&priv->lock); 78 79 if (!j1939_address_is_unicast(ecu->addr)) 80 return; 81 82 if (!j1939_ecu_is_mapped_locked(ecu)) 83 return; 84 85 ent = &priv->ents[ecu->addr]; 86 ent->ecu = NULL; 87 ent->nusers -= ecu->nusers; 88 j1939_ecu_put(ecu); 89} 90 91void j1939_ecu_unmap(struct j1939_ecu *ecu) 92{ 93 write_lock_bh(&ecu->priv->lock); 94 j1939_ecu_unmap_locked(ecu); 95 write_unlock_bh(&ecu->priv->lock); 96} 97 98void j1939_ecu_unmap_all(struct j1939_priv *priv) 99{ 100 int i; 101 102 write_lock_bh(&priv->lock); 103 for (i = 0; i < ARRAY_SIZE(priv->ents); i++) 104 if (priv->ents[i].ecu) 105 j1939_ecu_unmap_locked(priv->ents[i].ecu); 106 write_unlock_bh(&priv->lock); 107} 108 109void j1939_ecu_timer_start(struct j1939_ecu *ecu) 110{ 111 /* The ECU is held here and released in the 112 * j1939_ecu_timer_handler() or j1939_ecu_timer_cancel(). 113 */ 114 j1939_ecu_get(ecu); 115 116 /* Schedule timer in 250 msec to commit address change. */ 117 hrtimer_start(&ecu->ac_timer, ms_to_ktime(250), 118 HRTIMER_MODE_REL_SOFT); 119} 120 121void j1939_ecu_timer_cancel(struct j1939_ecu *ecu) 122{ 123 if (hrtimer_cancel(&ecu->ac_timer)) 124 j1939_ecu_put(ecu); 125} 126 127static enum hrtimer_restart j1939_ecu_timer_handler(struct hrtimer *hrtimer) 128{ 129 struct j1939_ecu *ecu = 130 container_of(hrtimer, struct j1939_ecu, ac_timer); 131 struct j1939_priv *priv = ecu->priv; 132 133 write_lock_bh(&priv->lock); 134 /* TODO: can we test if ecu->addr is unicast before starting 135 * the timer? 136 */ 137 j1939_ecu_map_locked(ecu); 138 139 /* The corresponding j1939_ecu_get() is in 140 * j1939_ecu_timer_start(). 141 */ 142 j1939_ecu_put(ecu); 143 write_unlock_bh(&priv->lock); 144 145 return HRTIMER_NORESTART; 146} 147 148struct j1939_ecu *j1939_ecu_create_locked(struct j1939_priv *priv, name_t name) 149{ 150 struct j1939_ecu *ecu; 151 152 lockdep_assert_held(&priv->lock); 153 154 ecu = kzalloc(sizeof(*ecu), gfp_any()); 155 if (!ecu) 156 return ERR_PTR(-ENOMEM); 157 kref_init(&ecu->kref); 158 ecu->addr = J1939_IDLE_ADDR; 159 ecu->name = name; 160 161 hrtimer_init(&ecu->ac_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT); 162 ecu->ac_timer.function = j1939_ecu_timer_handler; 163 INIT_LIST_HEAD(&ecu->list); 164 165 j1939_priv_get(priv); 166 ecu->priv = priv; 167 list_add_tail(&ecu->list, &priv->ecus); 168 169 return ecu; 170} 171 172struct j1939_ecu *j1939_ecu_find_by_addr_locked(struct j1939_priv *priv, 173 u8 addr) 174{ 175 lockdep_assert_held(&priv->lock); 176 177 return priv->ents[addr].ecu; 178} 179 180struct j1939_ecu *j1939_ecu_get_by_addr_locked(struct j1939_priv *priv, u8 addr) 181{ 182 struct j1939_ecu *ecu; 183 184 lockdep_assert_held(&priv->lock); 185 186 if (!j1939_address_is_unicast(addr)) 187 return NULL; 188 189 ecu = j1939_ecu_find_by_addr_locked(priv, addr); 190 if (ecu) 191 j1939_ecu_get(ecu); 192 193 return ecu; 194} 195 196struct j1939_ecu *j1939_ecu_get_by_addr(struct j1939_priv *priv, u8 addr) 197{ 198 struct j1939_ecu *ecu; 199 200 read_lock_bh(&priv->lock); 201 ecu = j1939_ecu_get_by_addr_locked(priv, addr); 202 read_unlock_bh(&priv->lock); 203 204 return ecu; 205} 206 207/* get pointer to ecu without increasing ref counter */ 208static struct j1939_ecu *j1939_ecu_find_by_name_locked(struct j1939_priv *priv, 209 name_t name) 210{ 211 struct j1939_ecu *ecu; 212 213 lockdep_assert_held(&priv->lock); 214 215 list_for_each_entry(ecu, &priv->ecus, list) { 216 if (ecu->name == name) 217 return ecu; 218 } 219 220 return NULL; 221} 222 223struct j1939_ecu *j1939_ecu_get_by_name_locked(struct j1939_priv *priv, 224 name_t name) 225{ 226 struct j1939_ecu *ecu; 227 228 lockdep_assert_held(&priv->lock); 229 230 if (!name) 231 return NULL; 232 233 ecu = j1939_ecu_find_by_name_locked(priv, name); 234 if (ecu) 235 j1939_ecu_get(ecu); 236 237 return ecu; 238} 239 240struct j1939_ecu *j1939_ecu_get_by_name(struct j1939_priv *priv, name_t name) 241{ 242 struct j1939_ecu *ecu; 243 244 read_lock_bh(&priv->lock); 245 ecu = j1939_ecu_get_by_name_locked(priv, name); 246 read_unlock_bh(&priv->lock); 247 248 return ecu; 249} 250 251u8 j1939_name_to_addr(struct j1939_priv *priv, name_t name) 252{ 253 struct j1939_ecu *ecu; 254 int addr = J1939_IDLE_ADDR; 255 256 if (!name) 257 return J1939_NO_ADDR; 258 259 read_lock_bh(&priv->lock); 260 ecu = j1939_ecu_find_by_name_locked(priv, name); 261 if (ecu && j1939_ecu_is_mapped_locked(ecu)) 262 /* ecu's SA is registered */ 263 addr = ecu->addr; 264 265 read_unlock_bh(&priv->lock); 266 267 return addr; 268} 269 270/* TX addr/name accounting 271 * Transport protocol needs to know if a SA is local or not 272 * These functions originate from userspace manipulating sockets, 273 * so locking is straigforward 274 */ 275 276int j1939_local_ecu_get(struct j1939_priv *priv, name_t name, u8 sa) 277{ 278 struct j1939_ecu *ecu; 279 int err = 0; 280 281 write_lock_bh(&priv->lock); 282 283 if (j1939_address_is_unicast(sa)) 284 priv->ents[sa].nusers++; 285 286 if (!name) 287 goto done; 288 289 ecu = j1939_ecu_get_by_name_locked(priv, name); 290 if (!ecu) 291 ecu = j1939_ecu_create_locked(priv, name); 292 err = PTR_ERR_OR_ZERO(ecu); 293 if (err) 294 goto done; 295 296 ecu->nusers++; 297 /* TODO: do we care if ecu->addr != sa? */ 298 if (j1939_ecu_is_mapped_locked(ecu)) 299 /* ecu's sa is active already */ 300 priv->ents[ecu->addr].nusers++; 301 302 done: 303 write_unlock_bh(&priv->lock); 304 305 return err; 306} 307 308void j1939_local_ecu_put(struct j1939_priv *priv, name_t name, u8 sa) 309{ 310 struct j1939_ecu *ecu; 311 312 write_lock_bh(&priv->lock); 313 314 if (j1939_address_is_unicast(sa)) 315 priv->ents[sa].nusers--; 316 317 if (!name) 318 goto done; 319 320 ecu = j1939_ecu_find_by_name_locked(priv, name); 321 if (WARN_ON_ONCE(!ecu)) 322 goto done; 323 324 ecu->nusers--; 325 /* TODO: do we care if ecu->addr != sa? */ 326 if (j1939_ecu_is_mapped_locked(ecu)) 327 /* ecu's sa is active already */ 328 priv->ents[ecu->addr].nusers--; 329 j1939_ecu_put(ecu); 330 331 done: 332 write_unlock_bh(&priv->lock); 333} 334