1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
3 * Copyright (C) 2006 Andrey Volkov, Varma Electronics
4 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
5 */
6
7 #include <linux/module.h>
8 #include <linux/kernel.h>
9 #include <linux/slab.h>
10 #include <linux/netdevice.h>
11 #include <linux/if_arp.h>
12 #include <linux/workqueue.h>
13 #include <linux/can.h>
14 #include <linux/can/can-ml.h>
15 #include <linux/can/dev.h>
16 #include <linux/can/skb.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/of.h>
19
20 #define MOD_DESC "CAN device driver interface"
21
22 MODULE_DESCRIPTION(MOD_DESC);
23 MODULE_LICENSE("GPL v2");
24 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
25
can_update_state_error_stats(struct net_device * dev,enum can_state new_state)26 static void can_update_state_error_stats(struct net_device *dev,
27 enum can_state new_state)
28 {
29 struct can_priv *priv = netdev_priv(dev);
30
31 if (new_state <= priv->state)
32 return;
33
34 switch (new_state) {
35 case CAN_STATE_ERROR_WARNING:
36 priv->can_stats.error_warning++;
37 break;
38 case CAN_STATE_ERROR_PASSIVE:
39 priv->can_stats.error_passive++;
40 break;
41 case CAN_STATE_BUS_OFF:
42 priv->can_stats.bus_off++;
43 break;
44 default:
45 break;
46 }
47 }
48
can_tx_state_to_frame(struct net_device * dev,enum can_state state)49 static int can_tx_state_to_frame(struct net_device *dev, enum can_state state)
50 {
51 switch (state) {
52 case CAN_STATE_ERROR_ACTIVE:
53 return CAN_ERR_CRTL_ACTIVE;
54 case CAN_STATE_ERROR_WARNING:
55 return CAN_ERR_CRTL_TX_WARNING;
56 case CAN_STATE_ERROR_PASSIVE:
57 return CAN_ERR_CRTL_TX_PASSIVE;
58 default:
59 return 0;
60 }
61 }
62
can_rx_state_to_frame(struct net_device * dev,enum can_state state)63 static int can_rx_state_to_frame(struct net_device *dev, enum can_state state)
64 {
65 switch (state) {
66 case CAN_STATE_ERROR_ACTIVE:
67 return CAN_ERR_CRTL_ACTIVE;
68 case CAN_STATE_ERROR_WARNING:
69 return CAN_ERR_CRTL_RX_WARNING;
70 case CAN_STATE_ERROR_PASSIVE:
71 return CAN_ERR_CRTL_RX_PASSIVE;
72 default:
73 return 0;
74 }
75 }
76
can_get_state_str(const enum can_state state)77 const char *can_get_state_str(const enum can_state state)
78 {
79 switch (state) {
80 case CAN_STATE_ERROR_ACTIVE:
81 return "Error Active";
82 case CAN_STATE_ERROR_WARNING:
83 return "Error Warning";
84 case CAN_STATE_ERROR_PASSIVE:
85 return "Error Passive";
86 case CAN_STATE_BUS_OFF:
87 return "Bus Off";
88 case CAN_STATE_STOPPED:
89 return "Stopped";
90 case CAN_STATE_SLEEPING:
91 return "Sleeping";
92 default:
93 return "<unknown>";
94 }
95
96 return "<unknown>";
97 }
98 EXPORT_SYMBOL_GPL(can_get_state_str);
99
can_change_state(struct net_device * dev,struct can_frame * cf,enum can_state tx_state,enum can_state rx_state)100 void can_change_state(struct net_device *dev, struct can_frame *cf,
101 enum can_state tx_state, enum can_state rx_state)
102 {
103 struct can_priv *priv = netdev_priv(dev);
104 enum can_state new_state = max(tx_state, rx_state);
105
106 if (unlikely(new_state == priv->state)) {
107 netdev_warn(dev, "%s: oops, state did not change", __func__);
108 return;
109 }
110
111 netdev_dbg(dev, "Controller changed from %s State (%d) into %s State (%d).\n",
112 can_get_state_str(priv->state), priv->state,
113 can_get_state_str(new_state), new_state);
114
115 can_update_state_error_stats(dev, new_state);
116 priv->state = new_state;
117
118 if (!cf)
119 return;
120
121 if (unlikely(new_state == CAN_STATE_BUS_OFF)) {
122 cf->can_id |= CAN_ERR_BUSOFF;
123 return;
124 }
125
126 cf->can_id |= CAN_ERR_CRTL;
127 cf->data[1] |= tx_state >= rx_state ?
128 can_tx_state_to_frame(dev, tx_state) : 0;
129 cf->data[1] |= tx_state <= rx_state ?
130 can_rx_state_to_frame(dev, rx_state) : 0;
131 }
132 EXPORT_SYMBOL_GPL(can_change_state);
133
134 /* CAN device restart for bus-off recovery */
can_restart(struct net_device * dev)135 static void can_restart(struct net_device *dev)
136 {
137 struct can_priv *priv = netdev_priv(dev);
138 struct sk_buff *skb;
139 struct can_frame *cf;
140 int err;
141
142 BUG_ON(netif_carrier_ok(dev));
143
144 /* No synchronization needed because the device is bus-off and
145 * no messages can come in or go out.
146 */
147 can_flush_echo_skb(dev);
148
149 /* send restart message upstream */
150 skb = alloc_can_err_skb(dev, &cf);
151 if (!skb)
152 goto restart;
153
154 cf->can_id |= CAN_ERR_RESTARTED;
155
156 netif_rx(skb);
157
158 restart:
159 netdev_dbg(dev, "restarted\n");
160 priv->can_stats.restarts++;
161
162 /* Now restart the device */
163 err = priv->do_set_mode(dev, CAN_MODE_START);
164
165 netif_carrier_on(dev);
166 if (err)
167 netdev_err(dev, "Error %d during restart", err);
168 }
169
can_restart_work(struct work_struct * work)170 static void can_restart_work(struct work_struct *work)
171 {
172 struct delayed_work *dwork = to_delayed_work(work);
173 struct can_priv *priv = container_of(dwork, struct can_priv,
174 restart_work);
175
176 can_restart(priv->dev);
177 }
178
can_restart_now(struct net_device * dev)179 int can_restart_now(struct net_device *dev)
180 {
181 struct can_priv *priv = netdev_priv(dev);
182
183 /* A manual restart is only permitted if automatic restart is
184 * disabled and the device is in the bus-off state
185 */
186 if (priv->restart_ms)
187 return -EINVAL;
188 if (priv->state != CAN_STATE_BUS_OFF)
189 return -EBUSY;
190
191 cancel_delayed_work_sync(&priv->restart_work);
192 can_restart(dev);
193
194 return 0;
195 }
196
197 /* CAN bus-off
198 *
199 * This functions should be called when the device goes bus-off to
200 * tell the netif layer that no more packets can be sent or received.
201 * If enabled, a timer is started to trigger bus-off recovery.
202 */
can_bus_off(struct net_device * dev)203 void can_bus_off(struct net_device *dev)
204 {
205 struct can_priv *priv = netdev_priv(dev);
206
207 if (priv->restart_ms)
208 netdev_info(dev, "bus-off, scheduling restart in %d ms\n",
209 priv->restart_ms);
210 else
211 netdev_info(dev, "bus-off\n");
212
213 netif_carrier_off(dev);
214
215 if (priv->restart_ms)
216 schedule_delayed_work(&priv->restart_work,
217 msecs_to_jiffies(priv->restart_ms));
218 }
219 EXPORT_SYMBOL_GPL(can_bus_off);
220
can_setup(struct net_device * dev)221 void can_setup(struct net_device *dev)
222 {
223 dev->type = ARPHRD_CAN;
224 dev->mtu = CAN_MTU;
225 dev->hard_header_len = 0;
226 dev->addr_len = 0;
227 dev->tx_queue_len = 10;
228
229 /* New-style flags. */
230 dev->flags = IFF_NOARP;
231 dev->features = NETIF_F_HW_CSUM;
232 }
233
234 /* Allocate and setup space for the CAN network device */
alloc_candev_mqs(int sizeof_priv,unsigned int echo_skb_max,unsigned int txqs,unsigned int rxqs)235 struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
236 unsigned int txqs, unsigned int rxqs)
237 {
238 struct can_ml_priv *can_ml;
239 struct net_device *dev;
240 struct can_priv *priv;
241 int size;
242
243 /* We put the driver's priv, the CAN mid layer priv and the
244 * echo skb into the netdevice's priv. The memory layout for
245 * the netdev_priv is like this:
246 *
247 * +-------------------------+
248 * | driver's priv |
249 * +-------------------------+
250 * | struct can_ml_priv |
251 * +-------------------------+
252 * | array of struct sk_buff |
253 * +-------------------------+
254 */
255
256 size = ALIGN(sizeof_priv, NETDEV_ALIGN) + sizeof(struct can_ml_priv);
257
258 if (echo_skb_max)
259 size = ALIGN(size, sizeof(struct sk_buff *)) +
260 echo_skb_max * sizeof(struct sk_buff *);
261
262 dev = alloc_netdev_mqs(size, "can%d", NET_NAME_UNKNOWN, can_setup,
263 txqs, rxqs);
264 if (!dev)
265 return NULL;
266
267 priv = netdev_priv(dev);
268 priv->dev = dev;
269
270 can_ml = (void *)priv + ALIGN(sizeof_priv, NETDEV_ALIGN);
271 can_set_ml_priv(dev, can_ml);
272
273 if (echo_skb_max) {
274 priv->echo_skb_max = echo_skb_max;
275 priv->echo_skb = (void *)priv +
276 (size - echo_skb_max * sizeof(struct sk_buff *));
277 }
278
279 priv->state = CAN_STATE_STOPPED;
280
281 INIT_DELAYED_WORK(&priv->restart_work, can_restart_work);
282
283 return dev;
284 }
285 EXPORT_SYMBOL_GPL(alloc_candev_mqs);
286
287 /* Free space of the CAN network device */
free_candev(struct net_device * dev)288 void free_candev(struct net_device *dev)
289 {
290 free_netdev(dev);
291 }
292 EXPORT_SYMBOL_GPL(free_candev);
293
294 /* changing MTU and control mode for CAN/CANFD devices */
can_change_mtu(struct net_device * dev,int new_mtu)295 int can_change_mtu(struct net_device *dev, int new_mtu)
296 {
297 struct can_priv *priv = netdev_priv(dev);
298 u32 ctrlmode_static = can_get_static_ctrlmode(priv);
299
300 /* Do not allow changing the MTU while running */
301 if (dev->flags & IFF_UP)
302 return -EBUSY;
303
304 /* allow change of MTU according to the CANFD ability of the device */
305 switch (new_mtu) {
306 case CAN_MTU:
307 /* 'CANFD-only' controllers can not switch to CAN_MTU */
308 if (ctrlmode_static & CAN_CTRLMODE_FD)
309 return -EINVAL;
310
311 priv->ctrlmode &= ~CAN_CTRLMODE_FD;
312 break;
313
314 case CANFD_MTU:
315 /* check for potential CANFD ability */
316 if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD) &&
317 !(ctrlmode_static & CAN_CTRLMODE_FD))
318 return -EINVAL;
319
320 priv->ctrlmode |= CAN_CTRLMODE_FD;
321 break;
322
323 default:
324 return -EINVAL;
325 }
326
327 dev->mtu = new_mtu;
328 return 0;
329 }
330 EXPORT_SYMBOL_GPL(can_change_mtu);
331
332 /* Common open function when the device gets opened.
333 *
334 * This function should be called in the open function of the device
335 * driver.
336 */
open_candev(struct net_device * dev)337 int open_candev(struct net_device *dev)
338 {
339 struct can_priv *priv = netdev_priv(dev);
340
341 if (!priv->bittiming.bitrate) {
342 netdev_err(dev, "bit-timing not yet defined\n");
343 return -EINVAL;
344 }
345
346 /* For CAN FD the data bitrate has to be >= the arbitration bitrate */
347 if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&
348 (!priv->data_bittiming.bitrate ||
349 priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {
350 netdev_err(dev, "incorrect/missing data bit-timing\n");
351 return -EINVAL;
352 }
353
354 /* Switch carrier on if device was stopped while in bus-off state */
355 if (!netif_carrier_ok(dev))
356 netif_carrier_on(dev);
357
358 return 0;
359 }
360 EXPORT_SYMBOL_GPL(open_candev);
361
362 #ifdef CONFIG_OF
363 /* Common function that can be used to understand the limitation of
364 * a transceiver when it provides no means to determine these limitations
365 * at runtime.
366 */
of_can_transceiver(struct net_device * dev)367 void of_can_transceiver(struct net_device *dev)
368 {
369 struct device_node *dn;
370 struct can_priv *priv = netdev_priv(dev);
371 struct device_node *np = dev->dev.parent->of_node;
372 int ret;
373
374 dn = of_get_child_by_name(np, "can-transceiver");
375 if (!dn)
376 return;
377
378 ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
379 of_node_put(dn);
380 if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
381 netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
382 }
383 EXPORT_SYMBOL_GPL(of_can_transceiver);
384 #endif
385
386 /* Common close function for cleanup before the device gets closed.
387 *
388 * This function should be called in the close function of the device
389 * driver.
390 */
close_candev(struct net_device * dev)391 void close_candev(struct net_device *dev)
392 {
393 struct can_priv *priv = netdev_priv(dev);
394
395 cancel_delayed_work_sync(&priv->restart_work);
396 can_flush_echo_skb(dev);
397 }
398 EXPORT_SYMBOL_GPL(close_candev);
399
can_set_termination(struct net_device * ndev,u16 term)400 static int can_set_termination(struct net_device *ndev, u16 term)
401 {
402 struct can_priv *priv = netdev_priv(ndev);
403 int set;
404
405 if (term == priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_ENABLED])
406 set = 1;
407 else
408 set = 0;
409
410 gpiod_set_value(priv->termination_gpio, set);
411
412 return 0;
413 }
414
can_get_termination(struct net_device * ndev)415 static int can_get_termination(struct net_device *ndev)
416 {
417 struct can_priv *priv = netdev_priv(ndev);
418 struct device *dev = ndev->dev.parent;
419 struct gpio_desc *gpio;
420 u32 term;
421 int ret;
422
423 /* Disabling termination by default is the safe choice: Else if many
424 * bus participants enable it, no communication is possible at all.
425 */
426 gpio = devm_gpiod_get_optional(dev, "termination", GPIOD_OUT_LOW);
427 if (IS_ERR(gpio))
428 return dev_err_probe(dev, PTR_ERR(gpio),
429 "Cannot get termination-gpios\n");
430
431 if (!gpio)
432 return 0;
433
434 ret = device_property_read_u32(dev, "termination-ohms", &term);
435 if (ret) {
436 netdev_err(ndev, "Cannot get termination-ohms: %pe\n",
437 ERR_PTR(ret));
438 return ret;
439 }
440
441 if (term > U16_MAX) {
442 netdev_err(ndev, "Invalid termination-ohms value (%u > %u)\n",
443 term, U16_MAX);
444 return -EINVAL;
445 }
446
447 priv->termination_const_cnt = ARRAY_SIZE(priv->termination_gpio_ohms);
448 priv->termination_const = priv->termination_gpio_ohms;
449 priv->termination_gpio = gpio;
450 priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_DISABLED] =
451 CAN_TERMINATION_DISABLED;
452 priv->termination_gpio_ohms[CAN_TERMINATION_GPIO_ENABLED] = term;
453 priv->do_set_termination = can_set_termination;
454
455 return 0;
456 }
457
458 /* Register the CAN network device */
register_candev(struct net_device * dev)459 int register_candev(struct net_device *dev)
460 {
461 struct can_priv *priv = netdev_priv(dev);
462 int err;
463
464 /* Ensure termination_const, termination_const_cnt and
465 * do_set_termination consistency. All must be either set or
466 * unset.
467 */
468 if ((!priv->termination_const != !priv->termination_const_cnt) ||
469 (!priv->termination_const != !priv->do_set_termination))
470 return -EINVAL;
471
472 if (!priv->bitrate_const != !priv->bitrate_const_cnt)
473 return -EINVAL;
474
475 if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt)
476 return -EINVAL;
477
478 if (!priv->termination_const) {
479 err = can_get_termination(dev);
480 if (err)
481 return err;
482 }
483
484 dev->rtnl_link_ops = &can_link_ops;
485 netif_carrier_off(dev);
486
487 return register_netdev(dev);
488 }
489 EXPORT_SYMBOL_GPL(register_candev);
490
491 /* Unregister the CAN network device */
unregister_candev(struct net_device * dev)492 void unregister_candev(struct net_device *dev)
493 {
494 unregister_netdev(dev);
495 }
496 EXPORT_SYMBOL_GPL(unregister_candev);
497
498 /* Test if a network device is a candev based device
499 * and return the can_priv* if so.
500 */
safe_candev_priv(struct net_device * dev)501 struct can_priv *safe_candev_priv(struct net_device *dev)
502 {
503 if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops)
504 return NULL;
505
506 return netdev_priv(dev);
507 }
508 EXPORT_SYMBOL_GPL(safe_candev_priv);
509
can_dev_init(void)510 static __init int can_dev_init(void)
511 {
512 int err;
513
514 err = can_netlink_register();
515 if (!err)
516 pr_info(MOD_DESC "\n");
517
518 return err;
519 }
520 module_init(can_dev_init);
521
can_dev_exit(void)522 static __exit void can_dev_exit(void)
523 {
524 can_netlink_unregister();
525 }
526 module_exit(can_dev_exit);
527
528 MODULE_ALIAS_RTNL_LINK("can");
529