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