1 // SPDX-License-Identifier: GPL-2.0
2
3 /* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.
4 *
5 * File es58x_core.c: Core logic to manage the network devices and the
6 * USB interface.
7 *
8 * Copyright (c) 2019 Robert Bosch Engineering and Business Solutions. All rights reserved.
9 * Copyright (c) 2020 ETAS K.K.. All rights reserved.
10 * Copyright (c) 2020, 2021 Vincent Mailhol <mailhol.vincent@wanadoo.fr>
11 */
12
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/usb.h>
16 #include <linux/crc16.h>
17 #include <asm/unaligned.h>
18
19 #include "es58x_core.h"
20
21 #define DRV_VERSION "1.00"
22 MODULE_AUTHOR("Mailhol Vincent <mailhol.vincent@wanadoo.fr>");
23 MODULE_AUTHOR("Arunachalam Santhanam <arunachalam.santhanam@in.bosch.com>");
24 MODULE_DESCRIPTION("Socket CAN driver for ETAS ES58X USB adapters");
25 MODULE_VERSION(DRV_VERSION);
26 MODULE_LICENSE("GPL v2");
27
28 #define ES58X_MODULE_NAME "etas_es58x"
29 #define ES58X_VENDOR_ID 0x108C
30 #define ES581_4_PRODUCT_ID 0x0159
31 #define ES582_1_PRODUCT_ID 0x0168
32 #define ES584_1_PRODUCT_ID 0x0169
33
34 /* ES58X FD has some interface protocols unsupported by this driver. */
35 #define ES58X_FD_INTERFACE_PROTOCOL 0
36
37 /* Table of devices which work with this driver. */
38 static const struct usb_device_id es58x_id_table[] = {
39 {
40 /* ETAS GmbH ES581.4 USB dual-channel CAN Bus Interface module. */
41 USB_DEVICE(ES58X_VENDOR_ID, ES581_4_PRODUCT_ID),
42 .driver_info = ES58X_DUAL_CHANNEL
43 }, {
44 /* ETAS GmbH ES582.1 USB dual-channel CAN FD Bus Interface module. */
45 USB_DEVICE_INTERFACE_PROTOCOL(ES58X_VENDOR_ID, ES582_1_PRODUCT_ID,
46 ES58X_FD_INTERFACE_PROTOCOL),
47 .driver_info = ES58X_DUAL_CHANNEL | ES58X_FD_FAMILY
48 }, {
49 /* ETAS GmbH ES584.1 USB single-channel CAN FD Bus Interface module. */
50 USB_DEVICE_INTERFACE_PROTOCOL(ES58X_VENDOR_ID, ES584_1_PRODUCT_ID,
51 ES58X_FD_INTERFACE_PROTOCOL),
52 .driver_info = ES58X_FD_FAMILY
53 }, {
54 /* Terminating entry */
55 }
56 };
57
58 MODULE_DEVICE_TABLE(usb, es58x_id_table);
59
60 #define es58x_print_hex_dump(buf, len) \
61 print_hex_dump(KERN_DEBUG, \
62 ES58X_MODULE_NAME " " __stringify(buf) ": ", \
63 DUMP_PREFIX_NONE, 16, 1, buf, len, false)
64
65 #define es58x_print_hex_dump_debug(buf, len) \
66 print_hex_dump_debug(ES58X_MODULE_NAME " " __stringify(buf) ": ",\
67 DUMP_PREFIX_NONE, 16, 1, buf, len, false)
68
69 /* The last two bytes of an ES58X command is a CRC16. The first two
70 * bytes (the start of frame) are skipped and the CRC calculation
71 * starts on the third byte.
72 */
73 #define ES58X_CRC_CALC_OFFSET 2
74
75 /**
76 * es58x_calculate_crc() - Compute the crc16 of a given URB.
77 * @urb_cmd: The URB command for which we want to calculate the CRC.
78 * @urb_len: Length of @urb_cmd. Must be at least bigger than 4
79 * (ES58X_CRC_CALC_OFFSET + sizeof(crc))
80 *
81 * Return: crc16 value.
82 */
es58x_calculate_crc(const union es58x_urb_cmd * urb_cmd,u16 urb_len)83 static u16 es58x_calculate_crc(const union es58x_urb_cmd *urb_cmd, u16 urb_len)
84 {
85 u16 crc;
86 ssize_t len = urb_len - ES58X_CRC_CALC_OFFSET - sizeof(crc);
87
88 crc = crc16(0, &urb_cmd->raw_cmd[ES58X_CRC_CALC_OFFSET], len);
89 return crc;
90 }
91
92 /**
93 * es58x_get_crc() - Get the CRC value of a given URB.
94 * @urb_cmd: The URB command for which we want to get the CRC.
95 * @urb_len: Length of @urb_cmd. Must be at least bigger than 4
96 * (ES58X_CRC_CALC_OFFSET + sizeof(crc))
97 *
98 * Return: crc16 value.
99 */
es58x_get_crc(const union es58x_urb_cmd * urb_cmd,u16 urb_len)100 static u16 es58x_get_crc(const union es58x_urb_cmd *urb_cmd, u16 urb_len)
101 {
102 u16 crc;
103 const __le16 *crc_addr;
104
105 crc_addr = (__le16 *)&urb_cmd->raw_cmd[urb_len - sizeof(crc)];
106 crc = get_unaligned_le16(crc_addr);
107 return crc;
108 }
109
110 /**
111 * es58x_set_crc() - Set the CRC value of a given URB.
112 * @urb_cmd: The URB command for which we want to get the CRC.
113 * @urb_len: Length of @urb_cmd. Must be at least bigger than 4
114 * (ES58X_CRC_CALC_OFFSET + sizeof(crc))
115 */
es58x_set_crc(union es58x_urb_cmd * urb_cmd,u16 urb_len)116 static void es58x_set_crc(union es58x_urb_cmd *urb_cmd, u16 urb_len)
117 {
118 u16 crc;
119 __le16 *crc_addr;
120
121 crc = es58x_calculate_crc(urb_cmd, urb_len);
122 crc_addr = (__le16 *)&urb_cmd->raw_cmd[urb_len - sizeof(crc)];
123 put_unaligned_le16(crc, crc_addr);
124 }
125
126 /**
127 * es58x_check_crc() - Validate the CRC value of a given URB.
128 * @es58x_dev: ES58X device.
129 * @urb_cmd: The URB command for which we want to check the CRC.
130 * @urb_len: Length of @urb_cmd. Must be at least bigger than 4
131 * (ES58X_CRC_CALC_OFFSET + sizeof(crc))
132 *
133 * Return: zero on success, -EBADMSG if the CRC check fails.
134 */
es58x_check_crc(struct es58x_device * es58x_dev,const union es58x_urb_cmd * urb_cmd,u16 urb_len)135 static int es58x_check_crc(struct es58x_device *es58x_dev,
136 const union es58x_urb_cmd *urb_cmd, u16 urb_len)
137 {
138 u16 calculated_crc = es58x_calculate_crc(urb_cmd, urb_len);
139 u16 expected_crc = es58x_get_crc(urb_cmd, urb_len);
140
141 if (expected_crc != calculated_crc) {
142 dev_err_ratelimited(es58x_dev->dev,
143 "%s: Bad CRC, urb_len: %d\n",
144 __func__, urb_len);
145 return -EBADMSG;
146 }
147
148 return 0;
149 }
150
151 /**
152 * es58x_timestamp_to_ns() - Convert a timestamp value received from a
153 * ES58X device to nanoseconds.
154 * @timestamp: Timestamp received from a ES58X device.
155 *
156 * The timestamp received from ES58X is expressed in multiples of 0.5
157 * micro seconds. This function converts it in to nanoseconds.
158 *
159 * Return: Timestamp value in nanoseconds.
160 */
es58x_timestamp_to_ns(u64 timestamp)161 static u64 es58x_timestamp_to_ns(u64 timestamp)
162 {
163 const u64 es58x_timestamp_ns_mult_coef = 500ULL;
164
165 return es58x_timestamp_ns_mult_coef * timestamp;
166 }
167
168 /**
169 * es58x_set_skb_timestamp() - Set the hardware timestamp of an skb.
170 * @netdev: CAN network device.
171 * @skb: socket buffer of a CAN message.
172 * @timestamp: Timestamp received from an ES58X device.
173 *
174 * Used for both received and echo messages.
175 */
es58x_set_skb_timestamp(struct net_device * netdev,struct sk_buff * skb,u64 timestamp)176 static void es58x_set_skb_timestamp(struct net_device *netdev,
177 struct sk_buff *skb, u64 timestamp)
178 {
179 struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;
180 struct skb_shared_hwtstamps *hwts;
181
182 hwts = skb_hwtstamps(skb);
183 /* Ignoring overflow (overflow on 64 bits timestamp with nano
184 * second precision would occur after more than 500 years).
185 */
186 hwts->hwtstamp = ns_to_ktime(es58x_timestamp_to_ns(timestamp) +
187 es58x_dev->realtime_diff_ns);
188 }
189
190 /**
191 * es58x_rx_timestamp() - Handle a received timestamp.
192 * @es58x_dev: ES58X device.
193 * @timestamp: Timestamp received from a ES58X device.
194 *
195 * Calculate the difference between the ES58X device and the kernel
196 * internal clocks. This difference will be later used as an offset to
197 * convert the timestamps of RX and echo messages to match the kernel
198 * system time (e.g. convert to UNIX time).
199 */
es58x_rx_timestamp(struct es58x_device * es58x_dev,u64 timestamp)200 void es58x_rx_timestamp(struct es58x_device *es58x_dev, u64 timestamp)
201 {
202 u64 ktime_real_ns = ktime_get_real_ns();
203 u64 device_timestamp = es58x_timestamp_to_ns(timestamp);
204
205 dev_dbg(es58x_dev->dev, "%s: request round-trip time: %llu ns\n",
206 __func__, ktime_real_ns - es58x_dev->ktime_req_ns);
207
208 es58x_dev->realtime_diff_ns =
209 (es58x_dev->ktime_req_ns + ktime_real_ns) / 2 - device_timestamp;
210 es58x_dev->ktime_req_ns = 0;
211
212 dev_dbg(es58x_dev->dev,
213 "%s: Device timestamp: %llu, diff with kernel: %llu\n",
214 __func__, device_timestamp, es58x_dev->realtime_diff_ns);
215 }
216
217 /**
218 * es58x_set_realtime_diff_ns() - Calculate difference between the
219 * clocks of the ES58X device and the kernel
220 * @es58x_dev: ES58X device.
221 *
222 * Request a timestamp from the ES58X device. Once the answer is
223 * received, the timestamp difference will be set by the callback
224 * function es58x_rx_timestamp().
225 *
226 * Return: zero on success, errno when any error occurs.
227 */
es58x_set_realtime_diff_ns(struct es58x_device * es58x_dev)228 static int es58x_set_realtime_diff_ns(struct es58x_device *es58x_dev)
229 {
230 if (es58x_dev->ktime_req_ns) {
231 dev_warn(es58x_dev->dev,
232 "%s: Previous request to set timestamp has not completed yet\n",
233 __func__);
234 return -EBUSY;
235 }
236
237 es58x_dev->ktime_req_ns = ktime_get_real_ns();
238 return es58x_dev->ops->get_timestamp(es58x_dev);
239 }
240
241 /**
242 * es58x_is_can_state_active() - Is the network device in an active
243 * CAN state?
244 * @netdev: CAN network device.
245 *
246 * The device is considered active if it is able to send or receive
247 * CAN frames, that is to say if it is in any of
248 * CAN_STATE_ERROR_ACTIVE, CAN_STATE_ERROR_WARNING or
249 * CAN_STATE_ERROR_PASSIVE states.
250 *
251 * Caution: when recovering from a bus-off,
252 * net/core/dev.c#can_restart() will call
253 * net/core/dev.c#can_flush_echo_skb() without using any kind of
254 * locks. For this reason, it is critical to guarantee that no TX or
255 * echo operations (i.e. any access to priv->echo_skb[]) can be done
256 * while this function is returning false.
257 *
258 * Return: true if the device is active, else returns false.
259 */
es58x_is_can_state_active(struct net_device * netdev)260 static bool es58x_is_can_state_active(struct net_device *netdev)
261 {
262 return es58x_priv(netdev)->can.state < CAN_STATE_BUS_OFF;
263 }
264
265 /**
266 * es58x_is_echo_skb_threshold_reached() - Determine the limit of how
267 * many skb slots can be taken before we should stop the network
268 * queue.
269 * @priv: ES58X private parameters related to the network device.
270 *
271 * We need to save enough free skb slots in order to be able to do
272 * bulk send. This function can be used to determine when to wake or
273 * stop the network queue in regard to the number of skb slots already
274 * taken if the echo FIFO.
275 *
276 * Return: boolean.
277 */
es58x_is_echo_skb_threshold_reached(struct es58x_priv * priv)278 static bool es58x_is_echo_skb_threshold_reached(struct es58x_priv *priv)
279 {
280 u32 num_echo_skb = priv->tx_head - priv->tx_tail;
281 u32 threshold = priv->can.echo_skb_max -
282 priv->es58x_dev->param->tx_bulk_max + 1;
283
284 return num_echo_skb >= threshold;
285 }
286
287 /**
288 * es58x_can_free_echo_skb_tail() - Remove the oldest echo skb of the
289 * echo FIFO.
290 * @netdev: CAN network device.
291 *
292 * Naming convention: the tail is the beginning of the FIFO, i.e. the
293 * first skb to have entered the FIFO.
294 */
es58x_can_free_echo_skb_tail(struct net_device * netdev)295 static void es58x_can_free_echo_skb_tail(struct net_device *netdev)
296 {
297 struct es58x_priv *priv = es58x_priv(netdev);
298 u16 fifo_mask = priv->es58x_dev->param->fifo_mask;
299 unsigned int frame_len = 0;
300
301 can_free_echo_skb(netdev, priv->tx_tail & fifo_mask, &frame_len);
302 netdev_completed_queue(netdev, 1, frame_len);
303
304 priv->tx_tail++;
305
306 netdev->stats.tx_dropped++;
307 }
308
309 /**
310 * es58x_can_get_echo_skb_recovery() - Try to re-sync the echo FIFO.
311 * @netdev: CAN network device.
312 * @rcv_packet_idx: Index
313 *
314 * This function should not be called under normal circumstances. In
315 * the unlikely case that one or several URB packages get dropped by
316 * the device, the index will get out of sync. Try to recover by
317 * dropping the echo skb packets with older indexes.
318 *
319 * Return: zero if recovery was successful, -EINVAL otherwise.
320 */
es58x_can_get_echo_skb_recovery(struct net_device * netdev,u32 rcv_packet_idx)321 static int es58x_can_get_echo_skb_recovery(struct net_device *netdev,
322 u32 rcv_packet_idx)
323 {
324 struct es58x_priv *priv = es58x_priv(netdev);
325 int ret = 0;
326
327 netdev->stats.tx_errors++;
328
329 if (net_ratelimit())
330 netdev_warn(netdev,
331 "Bad echo packet index: %u. First index: %u, end index %u, num_echo_skb: %02u/%02u\n",
332 rcv_packet_idx, priv->tx_tail, priv->tx_head,
333 priv->tx_head - priv->tx_tail,
334 priv->can.echo_skb_max);
335
336 if ((s32)(rcv_packet_idx - priv->tx_tail) < 0) {
337 if (net_ratelimit())
338 netdev_warn(netdev,
339 "Received echo index is from the past. Ignoring it\n");
340 ret = -EINVAL;
341 } else if ((s32)(rcv_packet_idx - priv->tx_head) >= 0) {
342 if (net_ratelimit())
343 netdev_err(netdev,
344 "Received echo index is from the future. Ignoring it\n");
345 ret = -EINVAL;
346 } else {
347 if (net_ratelimit())
348 netdev_warn(netdev,
349 "Recovery: dropping %u echo skb from index %u to %u\n",
350 rcv_packet_idx - priv->tx_tail,
351 priv->tx_tail, rcv_packet_idx - 1);
352 while (priv->tx_tail != rcv_packet_idx) {
353 if (priv->tx_tail == priv->tx_head)
354 return -EINVAL;
355 es58x_can_free_echo_skb_tail(netdev);
356 }
357 }
358 return ret;
359 }
360
361 /**
362 * es58x_can_get_echo_skb() - Get the skb from the echo FIFO and loop
363 * it back locally.
364 * @netdev: CAN network device.
365 * @rcv_packet_idx: Index of the first packet received from the device.
366 * @tstamps: Array of hardware timestamps received from a ES58X device.
367 * @pkts: Number of packets (and so, length of @tstamps).
368 *
369 * Callback function for when we receive a self reception
370 * acknowledgment. Retrieves the skb from the echo FIFO, sets its
371 * hardware timestamp (the actual time it was sent) and loops it back
372 * locally.
373 *
374 * The device has to be active (i.e. network interface UP and not in
375 * bus off state or restarting).
376 *
377 * Packet indexes must be consecutive (i.e. index of first packet is
378 * @rcv_packet_idx, index of second packet is @rcv_packet_idx + 1 and
379 * index of last packet is @rcv_packet_idx + @pkts - 1).
380 *
381 * Return: zero on success.
382 */
es58x_can_get_echo_skb(struct net_device * netdev,u32 rcv_packet_idx,u64 * tstamps,unsigned int pkts)383 int es58x_can_get_echo_skb(struct net_device *netdev, u32 rcv_packet_idx,
384 u64 *tstamps, unsigned int pkts)
385 {
386 struct es58x_priv *priv = es58x_priv(netdev);
387 unsigned int rx_total_frame_len = 0;
388 unsigned int num_echo_skb = priv->tx_head - priv->tx_tail;
389 int i;
390 u16 fifo_mask = priv->es58x_dev->param->fifo_mask;
391
392 if (!netif_running(netdev)) {
393 if (net_ratelimit())
394 netdev_info(netdev,
395 "%s: %s is down, dropping %d echo packets\n",
396 __func__, netdev->name, pkts);
397 netdev->stats.tx_dropped += pkts;
398 return 0;
399 } else if (!es58x_is_can_state_active(netdev)) {
400 if (net_ratelimit())
401 netdev_dbg(netdev,
402 "Bus is off or device is restarting. Ignoring %u echo packets from index %u\n",
403 pkts, rcv_packet_idx);
404 /* stats.tx_dropped will be (or was already)
405 * incremented by
406 * drivers/net/can/net/dev.c:can_flush_echo_skb().
407 */
408 return 0;
409 } else if (num_echo_skb == 0) {
410 if (net_ratelimit())
411 netdev_warn(netdev,
412 "Received %u echo packets from index: %u but echo skb queue is empty.\n",
413 pkts, rcv_packet_idx);
414 netdev->stats.tx_dropped += pkts;
415 return 0;
416 }
417
418 if (priv->tx_tail != rcv_packet_idx) {
419 if (es58x_can_get_echo_skb_recovery(netdev, rcv_packet_idx) < 0) {
420 if (net_ratelimit())
421 netdev_warn(netdev,
422 "Could not find echo skb for echo packet index: %u\n",
423 rcv_packet_idx);
424 return 0;
425 }
426 }
427 if (num_echo_skb < pkts) {
428 int pkts_drop = pkts - num_echo_skb;
429
430 if (net_ratelimit())
431 netdev_err(netdev,
432 "Received %u echo packets but have only %d echo skb. Dropping %d echo skb\n",
433 pkts, num_echo_skb, pkts_drop);
434 netdev->stats.tx_dropped += pkts_drop;
435 pkts -= pkts_drop;
436 }
437
438 for (i = 0; i < pkts; i++) {
439 unsigned int skb_idx = priv->tx_tail & fifo_mask;
440 struct sk_buff *skb = priv->can.echo_skb[skb_idx];
441 unsigned int frame_len = 0;
442
443 if (skb)
444 es58x_set_skb_timestamp(netdev, skb, tstamps[i]);
445
446 netdev->stats.tx_bytes += can_get_echo_skb(netdev, skb_idx,
447 &frame_len);
448 rx_total_frame_len += frame_len;
449
450 priv->tx_tail++;
451 }
452
453 netdev_completed_queue(netdev, pkts, rx_total_frame_len);
454 netdev->stats.tx_packets += pkts;
455
456 priv->err_passive_before_rtx_success = 0;
457 if (!es58x_is_echo_skb_threshold_reached(priv))
458 netif_wake_queue(netdev);
459
460 return 0;
461 }
462
463 /**
464 * es58x_can_reset_echo_fifo() - Reset the echo FIFO.
465 * @netdev: CAN network device.
466 *
467 * The echo_skb array of struct can_priv will be flushed by
468 * drivers/net/can/dev.c:can_flush_echo_skb(). This function resets
469 * the parameters of the struct es58x_priv of our device and reset the
470 * queue (c.f. BQL).
471 */
es58x_can_reset_echo_fifo(struct net_device * netdev)472 static void es58x_can_reset_echo_fifo(struct net_device *netdev)
473 {
474 struct es58x_priv *priv = es58x_priv(netdev);
475
476 priv->tx_tail = 0;
477 priv->tx_head = 0;
478 priv->tx_urb = NULL;
479 priv->err_passive_before_rtx_success = 0;
480 netdev_reset_queue(netdev);
481 }
482
483 /**
484 * es58x_flush_pending_tx_msg() - Reset the buffer for transmission messages.
485 * @netdev: CAN network device.
486 *
487 * es58x_start_xmit() will queue up to tx_bulk_max messages in
488 * &tx_urb buffer and do a bulk send of all messages in one single URB
489 * (c.f. xmit_more flag). When the device recovers from a bus off
490 * state or when the device stops, the tx_urb buffer might still have
491 * pending messages in it and thus need to be flushed.
492 */
es58x_flush_pending_tx_msg(struct net_device * netdev)493 static void es58x_flush_pending_tx_msg(struct net_device *netdev)
494 {
495 struct es58x_priv *priv = es58x_priv(netdev);
496 struct es58x_device *es58x_dev = priv->es58x_dev;
497
498 if (priv->tx_urb) {
499 netdev_warn(netdev, "%s: dropping %d TX messages\n",
500 __func__, priv->tx_can_msg_cnt);
501 netdev->stats.tx_dropped += priv->tx_can_msg_cnt;
502 while (priv->tx_can_msg_cnt > 0) {
503 unsigned int frame_len = 0;
504 u16 fifo_mask = priv->es58x_dev->param->fifo_mask;
505
506 priv->tx_head--;
507 priv->tx_can_msg_cnt--;
508 can_free_echo_skb(netdev, priv->tx_head & fifo_mask,
509 &frame_len);
510 netdev_completed_queue(netdev, 1, frame_len);
511 }
512 usb_anchor_urb(priv->tx_urb, &priv->es58x_dev->tx_urbs_idle);
513 atomic_inc(&es58x_dev->tx_urbs_idle_cnt);
514 usb_free_urb(priv->tx_urb);
515 }
516 priv->tx_urb = NULL;
517 }
518
519 /**
520 * es58x_tx_ack_msg() - Handle acknowledgment messages.
521 * @netdev: CAN network device.
522 * @tx_free_entries: Number of free entries in the device transmit FIFO.
523 * @rx_cmd_ret_u32: error code as returned by the ES58X device.
524 *
525 * ES58X sends an acknowledgment message after a transmission request
526 * is done. This is mandatory for the ES581.4 but is optional (and
527 * deactivated in this driver) for the ES58X_FD family.
528 *
529 * Under normal circumstances, this function should never throw an
530 * error message.
531 *
532 * Return: zero on success, errno when any error occurs.
533 */
es58x_tx_ack_msg(struct net_device * netdev,u16 tx_free_entries,enum es58x_ret_u32 rx_cmd_ret_u32)534 int es58x_tx_ack_msg(struct net_device *netdev, u16 tx_free_entries,
535 enum es58x_ret_u32 rx_cmd_ret_u32)
536 {
537 struct es58x_priv *priv = es58x_priv(netdev);
538
539 if (tx_free_entries <= priv->es58x_dev->param->tx_bulk_max) {
540 if (net_ratelimit())
541 netdev_err(netdev,
542 "Only %d entries left in device queue, num_echo_skb: %d/%d\n",
543 tx_free_entries,
544 priv->tx_head - priv->tx_tail,
545 priv->can.echo_skb_max);
546 netif_stop_queue(netdev);
547 }
548
549 return es58x_rx_cmd_ret_u32(netdev, ES58X_RET_TYPE_TX_MSG,
550 rx_cmd_ret_u32);
551 }
552
553 /**
554 * es58x_rx_can_msg() - Handle a received a CAN message.
555 * @netdev: CAN network device.
556 * @timestamp: Hardware time stamp (only relevant in rx branches).
557 * @data: CAN payload.
558 * @can_id: CAN ID.
559 * @es58x_flags: Please refer to enum es58x_flag.
560 * @dlc: Data Length Code (raw value).
561 *
562 * Fill up a CAN skb and post it.
563 *
564 * This function handles the case where the DLC of a classical CAN
565 * frame is greater than CAN_MAX_DLEN (c.f. the len8_dlc field of
566 * struct can_frame).
567 *
568 * Return: zero on success.
569 */
es58x_rx_can_msg(struct net_device * netdev,u64 timestamp,const u8 * data,canid_t can_id,enum es58x_flag es58x_flags,u8 dlc)570 int es58x_rx_can_msg(struct net_device *netdev, u64 timestamp, const u8 *data,
571 canid_t can_id, enum es58x_flag es58x_flags, u8 dlc)
572 {
573 struct canfd_frame *cfd;
574 struct can_frame *ccf;
575 struct sk_buff *skb;
576 u8 len;
577 bool is_can_fd = !!(es58x_flags & ES58X_FLAG_FD_DATA);
578
579 if (dlc > CAN_MAX_RAW_DLC) {
580 netdev_err(netdev,
581 "%s: DLC is %d but maximum should be %d\n",
582 __func__, dlc, CAN_MAX_RAW_DLC);
583 return -EMSGSIZE;
584 }
585
586 if (is_can_fd) {
587 len = can_fd_dlc2len(dlc);
588 skb = alloc_canfd_skb(netdev, &cfd);
589 } else {
590 len = can_cc_dlc2len(dlc);
591 skb = alloc_can_skb(netdev, &ccf);
592 cfd = (struct canfd_frame *)ccf;
593 }
594 if (!skb) {
595 netdev->stats.rx_dropped++;
596 return 0;
597 }
598
599 cfd->can_id = can_id;
600 if (es58x_flags & ES58X_FLAG_EFF)
601 cfd->can_id |= CAN_EFF_FLAG;
602 if (is_can_fd) {
603 cfd->len = len;
604 if (es58x_flags & ES58X_FLAG_FD_BRS)
605 cfd->flags |= CANFD_BRS;
606 if (es58x_flags & ES58X_FLAG_FD_ESI)
607 cfd->flags |= CANFD_ESI;
608 } else {
609 can_frame_set_cc_len(ccf, dlc, es58x_priv(netdev)->can.ctrlmode);
610 if (es58x_flags & ES58X_FLAG_RTR) {
611 ccf->can_id |= CAN_RTR_FLAG;
612 len = 0;
613 }
614 }
615 memcpy(cfd->data, data, len);
616 netdev->stats.rx_packets++;
617 netdev->stats.rx_bytes += len;
618
619 es58x_set_skb_timestamp(netdev, skb, timestamp);
620 netif_rx(skb);
621
622 es58x_priv(netdev)->err_passive_before_rtx_success = 0;
623
624 return 0;
625 }
626
627 /**
628 * es58x_rx_err_msg() - Handle a received CAN event or error message.
629 * @netdev: CAN network device.
630 * @error: Error code.
631 * @event: Event code.
632 * @timestamp: Timestamp received from a ES58X device.
633 *
634 * Handle the errors and events received by the ES58X device, create
635 * a CAN error skb and post it.
636 *
637 * In some rare cases the devices might get stuck alternating between
638 * CAN_STATE_ERROR_PASSIVE and CAN_STATE_ERROR_WARNING. To prevent
639 * this behavior, we force a bus off state if the device goes in
640 * CAN_STATE_ERROR_WARNING for ES58X_MAX_CONSECUTIVE_WARN consecutive
641 * times with no successful transmission or reception in between.
642 *
643 * Once the device is in bus off state, the only way to restart it is
644 * through the drivers/net/can/dev.c:can_restart() function. The
645 * device is technically capable to recover by itself under certain
646 * circumstances, however, allowing self recovery would create
647 * complex race conditions with drivers/net/can/dev.c:can_restart()
648 * and thus was not implemented. To activate automatic restart, please
649 * set the restart-ms parameter (e.g. ip link set can0 type can
650 * restart-ms 100).
651 *
652 * If the bus is really instable, this function would try to send a
653 * lot of log messages. Those are rate limited (i.e. you will see
654 * messages such as "net_ratelimit: XXX callbacks suppressed" in
655 * dmesg).
656 *
657 * Return: zero on success, errno when any error occurs.
658 */
es58x_rx_err_msg(struct net_device * netdev,enum es58x_err error,enum es58x_event event,u64 timestamp)659 int es58x_rx_err_msg(struct net_device *netdev, enum es58x_err error,
660 enum es58x_event event, u64 timestamp)
661 {
662 struct es58x_priv *priv = es58x_priv(netdev);
663 struct can_priv *can = netdev_priv(netdev);
664 struct can_device_stats *can_stats = &can->can_stats;
665 struct can_frame *cf = NULL;
666 struct sk_buff *skb;
667 int ret;
668
669 if (!netif_running(netdev)) {
670 if (net_ratelimit())
671 netdev_info(netdev, "%s: %s is down, dropping packet\n",
672 __func__, netdev->name);
673 netdev->stats.rx_dropped++;
674 return 0;
675 }
676
677 if (error == ES58X_ERR_OK && event == ES58X_EVENT_OK) {
678 netdev_err(netdev, "%s: Both error and event are zero\n",
679 __func__);
680 return -EINVAL;
681 }
682
683 skb = alloc_can_err_skb(netdev, &cf);
684
685 switch (error) {
686 case ES58X_ERR_OK: /* 0: No error */
687 break;
688
689 case ES58X_ERR_PROT_STUFF:
690 if (net_ratelimit())
691 netdev_dbg(netdev, "Error BITSTUFF\n");
692 if (cf)
693 cf->data[2] |= CAN_ERR_PROT_STUFF;
694 break;
695
696 case ES58X_ERR_PROT_FORM:
697 if (net_ratelimit())
698 netdev_dbg(netdev, "Error FORMAT\n");
699 if (cf)
700 cf->data[2] |= CAN_ERR_PROT_FORM;
701 break;
702
703 case ES58X_ERR_ACK:
704 if (net_ratelimit())
705 netdev_dbg(netdev, "Error ACK\n");
706 if (cf)
707 cf->can_id |= CAN_ERR_ACK;
708 break;
709
710 case ES58X_ERR_PROT_BIT:
711 if (net_ratelimit())
712 netdev_dbg(netdev, "Error BIT\n");
713 if (cf)
714 cf->data[2] |= CAN_ERR_PROT_BIT;
715 break;
716
717 case ES58X_ERR_PROT_CRC:
718 if (net_ratelimit())
719 netdev_dbg(netdev, "Error CRC\n");
720 if (cf)
721 cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ;
722 break;
723
724 case ES58X_ERR_PROT_BIT1:
725 if (net_ratelimit())
726 netdev_dbg(netdev,
727 "Error: expected a recessive bit but monitored a dominant one\n");
728 if (cf)
729 cf->data[2] |= CAN_ERR_PROT_BIT1;
730 break;
731
732 case ES58X_ERR_PROT_BIT0:
733 if (net_ratelimit())
734 netdev_dbg(netdev,
735 "Error expected a dominant bit but monitored a recessive one\n");
736 if (cf)
737 cf->data[2] |= CAN_ERR_PROT_BIT0;
738 break;
739
740 case ES58X_ERR_PROT_OVERLOAD:
741 if (net_ratelimit())
742 netdev_dbg(netdev, "Error OVERLOAD\n");
743 if (cf)
744 cf->data[2] |= CAN_ERR_PROT_OVERLOAD;
745 break;
746
747 case ES58X_ERR_PROT_UNSPEC:
748 if (net_ratelimit())
749 netdev_dbg(netdev, "Unspecified error\n");
750 if (cf)
751 cf->can_id |= CAN_ERR_PROT;
752 break;
753
754 default:
755 if (net_ratelimit())
756 netdev_err(netdev,
757 "%s: Unspecified error code 0x%04X\n",
758 __func__, (int)error);
759 if (cf)
760 cf->can_id |= CAN_ERR_PROT;
761 break;
762 }
763
764 switch (event) {
765 case ES58X_EVENT_OK: /* 0: No event */
766 break;
767
768 case ES58X_EVENT_CRTL_ACTIVE:
769 if (can->state == CAN_STATE_BUS_OFF) {
770 netdev_err(netdev,
771 "%s: state transition: BUS OFF -> ACTIVE\n",
772 __func__);
773 }
774 if (net_ratelimit())
775 netdev_dbg(netdev, "Event CAN BUS ACTIVE\n");
776 if (cf)
777 cf->data[1] |= CAN_ERR_CRTL_ACTIVE;
778 can->state = CAN_STATE_ERROR_ACTIVE;
779 break;
780
781 case ES58X_EVENT_CRTL_PASSIVE:
782 if (net_ratelimit())
783 netdev_dbg(netdev, "Event CAN BUS PASSIVE\n");
784 /* Either TX or RX error count reached passive state
785 * but we do not know which. Setting both flags by
786 * default.
787 */
788 if (cf) {
789 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
790 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
791 }
792 if (can->state < CAN_STATE_BUS_OFF)
793 can->state = CAN_STATE_ERROR_PASSIVE;
794 can_stats->error_passive++;
795 if (priv->err_passive_before_rtx_success < U8_MAX)
796 priv->err_passive_before_rtx_success++;
797 break;
798
799 case ES58X_EVENT_CRTL_WARNING:
800 if (net_ratelimit())
801 netdev_dbg(netdev, "Event CAN BUS WARNING\n");
802 /* Either TX or RX error count reached warning state
803 * but we do not know which. Setting both flags by
804 * default.
805 */
806 if (cf) {
807 cf->data[1] |= CAN_ERR_CRTL_RX_WARNING;
808 cf->data[1] |= CAN_ERR_CRTL_TX_WARNING;
809 }
810 if (can->state < CAN_STATE_BUS_OFF)
811 can->state = CAN_STATE_ERROR_WARNING;
812 can_stats->error_warning++;
813 break;
814
815 case ES58X_EVENT_BUSOFF:
816 if (net_ratelimit())
817 netdev_dbg(netdev, "Event CAN BUS OFF\n");
818 if (cf)
819 cf->can_id |= CAN_ERR_BUSOFF;
820 can_stats->bus_off++;
821 netif_stop_queue(netdev);
822 if (can->state != CAN_STATE_BUS_OFF) {
823 can->state = CAN_STATE_BUS_OFF;
824 can_bus_off(netdev);
825 ret = can->do_set_mode(netdev, CAN_MODE_STOP);
826 if (ret)
827 return ret;
828 }
829 break;
830
831 case ES58X_EVENT_SINGLE_WIRE:
832 if (net_ratelimit())
833 netdev_warn(netdev,
834 "Lost connection on either CAN high or CAN low\n");
835 /* Lost connection on either CAN high or CAN
836 * low. Setting both flags by default.
837 */
838 if (cf) {
839 cf->data[4] |= CAN_ERR_TRX_CANH_NO_WIRE;
840 cf->data[4] |= CAN_ERR_TRX_CANL_NO_WIRE;
841 }
842 break;
843
844 default:
845 if (net_ratelimit())
846 netdev_err(netdev,
847 "%s: Unspecified event code 0x%04X\n",
848 __func__, (int)event);
849 if (cf)
850 cf->can_id |= CAN_ERR_CRTL;
851 break;
852 }
853
854 /* driver/net/can/dev.c:can_restart() takes in account error
855 * messages in the RX stats. Doing the same here for
856 * consistency.
857 */
858 netdev->stats.rx_packets++;
859 netdev->stats.rx_bytes += CAN_ERR_DLC;
860
861 if (cf) {
862 if (cf->data[1])
863 cf->can_id |= CAN_ERR_CRTL;
864 if (cf->data[2] || cf->data[3]) {
865 cf->can_id |= CAN_ERR_PROT;
866 can_stats->bus_error++;
867 }
868 if (cf->data[4])
869 cf->can_id |= CAN_ERR_TRX;
870
871 es58x_set_skb_timestamp(netdev, skb, timestamp);
872 netif_rx(skb);
873 }
874
875 if ((event & ES58X_EVENT_CRTL_PASSIVE) &&
876 priv->err_passive_before_rtx_success == ES58X_CONSECUTIVE_ERR_PASSIVE_MAX) {
877 netdev_info(netdev,
878 "Got %d consecutive warning events with no successful RX or TX. Forcing bus-off\n",
879 priv->err_passive_before_rtx_success);
880 return es58x_rx_err_msg(netdev, ES58X_ERR_OK,
881 ES58X_EVENT_BUSOFF, timestamp);
882 }
883
884 return 0;
885 }
886
887 /**
888 * es58x_cmd_ret_desc() - Convert a command type to a string.
889 * @cmd_ret_type: Type of the command which triggered the return code.
890 *
891 * The final line (return "<unknown>") should not be reached. If this
892 * is the case, there is an implementation bug.
893 *
894 * Return: a readable description of the @cmd_ret_type.
895 */
es58x_cmd_ret_desc(enum es58x_ret_type cmd_ret_type)896 static const char *es58x_cmd_ret_desc(enum es58x_ret_type cmd_ret_type)
897 {
898 switch (cmd_ret_type) {
899 case ES58X_RET_TYPE_SET_BITTIMING:
900 return "Set bittiming";
901 case ES58X_RET_TYPE_ENABLE_CHANNEL:
902 return "Enable channel";
903 case ES58X_RET_TYPE_DISABLE_CHANNEL:
904 return "Disable channel";
905 case ES58X_RET_TYPE_TX_MSG:
906 return "Transmit message";
907 case ES58X_RET_TYPE_RESET_RX:
908 return "Reset RX";
909 case ES58X_RET_TYPE_RESET_TX:
910 return "Reset TX";
911 case ES58X_RET_TYPE_DEVICE_ERR:
912 return "Device error";
913 }
914
915 return "<unknown>";
916 };
917
918 /**
919 * es58x_rx_cmd_ret_u8() - Handle the command's return code received
920 * from the ES58X device.
921 * @dev: Device, only used for the dev_XXX() print functions.
922 * @cmd_ret_type: Type of the command which triggered the return code.
923 * @rx_cmd_ret_u8: Command error code as returned by the ES58X device.
924 *
925 * Handles the 8 bits command return code. Those are specific to the
926 * ES581.4 device. The return value will eventually be used by
927 * es58x_handle_urb_cmd() function which will take proper actions in
928 * case of critical issues such and memory errors or bad CRC values.
929 *
930 * In contrast with es58x_rx_cmd_ret_u32(), the network device is
931 * unknown.
932 *
933 * Return: zero on success, return errno when any error occurs.
934 */
es58x_rx_cmd_ret_u8(struct device * dev,enum es58x_ret_type cmd_ret_type,enum es58x_ret_u8 rx_cmd_ret_u8)935 int es58x_rx_cmd_ret_u8(struct device *dev,
936 enum es58x_ret_type cmd_ret_type,
937 enum es58x_ret_u8 rx_cmd_ret_u8)
938 {
939 const char *ret_desc = es58x_cmd_ret_desc(cmd_ret_type);
940
941 switch (rx_cmd_ret_u8) {
942 case ES58X_RET_U8_OK:
943 dev_dbg_ratelimited(dev, "%s: OK\n", ret_desc);
944 return 0;
945
946 case ES58X_RET_U8_ERR_UNSPECIFIED_FAILURE:
947 dev_err(dev, "%s: unspecified failure\n", ret_desc);
948 return -EBADMSG;
949
950 case ES58X_RET_U8_ERR_NO_MEM:
951 dev_err(dev, "%s: device ran out of memory\n", ret_desc);
952 return -ENOMEM;
953
954 case ES58X_RET_U8_ERR_BAD_CRC:
955 dev_err(dev, "%s: CRC of previous command is incorrect\n",
956 ret_desc);
957 return -EIO;
958
959 default:
960 dev_err(dev, "%s: returned unknown value: 0x%02X\n",
961 ret_desc, rx_cmd_ret_u8);
962 return -EBADMSG;
963 }
964 }
965
966 /**
967 * es58x_rx_cmd_ret_u32() - Handle the command return code received
968 * from the ES58X device.
969 * @netdev: CAN network device.
970 * @cmd_ret_type: Type of the command which triggered the return code.
971 * @rx_cmd_ret_u32: error code as returned by the ES58X device.
972 *
973 * Handles the 32 bits command return code. The return value will
974 * eventually be used by es58x_handle_urb_cmd() function which will
975 * take proper actions in case of critical issues such and memory
976 * errors or bad CRC values.
977 *
978 * Return: zero on success, errno when any error occurs.
979 */
es58x_rx_cmd_ret_u32(struct net_device * netdev,enum es58x_ret_type cmd_ret_type,enum es58x_ret_u32 rx_cmd_ret_u32)980 int es58x_rx_cmd_ret_u32(struct net_device *netdev,
981 enum es58x_ret_type cmd_ret_type,
982 enum es58x_ret_u32 rx_cmd_ret_u32)
983 {
984 struct es58x_priv *priv = es58x_priv(netdev);
985 const struct es58x_operators *ops = priv->es58x_dev->ops;
986 const char *ret_desc = es58x_cmd_ret_desc(cmd_ret_type);
987
988 switch (rx_cmd_ret_u32) {
989 case ES58X_RET_U32_OK:
990 switch (cmd_ret_type) {
991 case ES58X_RET_TYPE_ENABLE_CHANNEL:
992 es58x_can_reset_echo_fifo(netdev);
993 priv->can.state = CAN_STATE_ERROR_ACTIVE;
994 netif_wake_queue(netdev);
995 netdev_info(netdev,
996 "%s: %s (Serial Number %s): CAN%d channel becomes ready\n",
997 ret_desc, priv->es58x_dev->udev->product,
998 priv->es58x_dev->udev->serial,
999 priv->channel_idx + 1);
1000 break;
1001
1002 case ES58X_RET_TYPE_TX_MSG:
1003 if (IS_ENABLED(CONFIG_VERBOSE_DEBUG) && net_ratelimit())
1004 netdev_vdbg(netdev, "%s: OK\n", ret_desc);
1005 break;
1006
1007 default:
1008 netdev_dbg(netdev, "%s: OK\n", ret_desc);
1009 break;
1010 }
1011 return 0;
1012
1013 case ES58X_RET_U32_ERR_UNSPECIFIED_FAILURE:
1014 if (cmd_ret_type == ES58X_RET_TYPE_ENABLE_CHANNEL) {
1015 int ret;
1016
1017 netdev_warn(netdev,
1018 "%s: channel is already opened, closing and re-opening it to reflect new configuration\n",
1019 ret_desc);
1020 ret = ops->disable_channel(es58x_priv(netdev));
1021 if (ret)
1022 return ret;
1023 return ops->enable_channel(es58x_priv(netdev));
1024 }
1025 if (cmd_ret_type == ES58X_RET_TYPE_DISABLE_CHANNEL) {
1026 netdev_info(netdev,
1027 "%s: channel is already closed\n", ret_desc);
1028 return 0;
1029 }
1030 netdev_err(netdev,
1031 "%s: unspecified failure\n", ret_desc);
1032 return -EBADMSG;
1033
1034 case ES58X_RET_U32_ERR_NO_MEM:
1035 netdev_err(netdev, "%s: device ran out of memory\n", ret_desc);
1036 return -ENOMEM;
1037
1038 case ES58X_RET_U32_WARN_PARAM_ADJUSTED:
1039 netdev_warn(netdev,
1040 "%s: some incompatible parameters have been adjusted\n",
1041 ret_desc);
1042 return 0;
1043
1044 case ES58X_RET_U32_WARN_TX_MAYBE_REORDER:
1045 netdev_warn(netdev,
1046 "%s: TX messages might have been reordered\n",
1047 ret_desc);
1048 return 0;
1049
1050 case ES58X_RET_U32_ERR_TIMEDOUT:
1051 netdev_err(netdev, "%s: command timed out\n", ret_desc);
1052 return -ETIMEDOUT;
1053
1054 case ES58X_RET_U32_ERR_FIFO_FULL:
1055 netdev_warn(netdev, "%s: fifo is full\n", ret_desc);
1056 return 0;
1057
1058 case ES58X_RET_U32_ERR_BAD_CONFIG:
1059 netdev_err(netdev, "%s: bad configuration\n", ret_desc);
1060 return -EINVAL;
1061
1062 case ES58X_RET_U32_ERR_NO_RESOURCE:
1063 netdev_err(netdev, "%s: no resource available\n", ret_desc);
1064 return -EBUSY;
1065
1066 default:
1067 netdev_err(netdev, "%s returned unknown value: 0x%08X\n",
1068 ret_desc, rx_cmd_ret_u32);
1069 return -EBADMSG;
1070 }
1071 }
1072
1073 /**
1074 * es58x_increment_rx_errors() - Increment the network devices' error
1075 * count.
1076 * @es58x_dev: ES58X device.
1077 *
1078 * If an error occurs on the early stages on receiving an URB command,
1079 * we might not be able to figure out on which network device the
1080 * error occurred. In such case, we arbitrarily increment the error
1081 * count of all the network devices attached to our ES58X device.
1082 */
es58x_increment_rx_errors(struct es58x_device * es58x_dev)1083 static void es58x_increment_rx_errors(struct es58x_device *es58x_dev)
1084 {
1085 int i;
1086
1087 for (i = 0; i < es58x_dev->num_can_ch; i++)
1088 if (es58x_dev->netdev[i])
1089 es58x_dev->netdev[i]->stats.rx_errors++;
1090 }
1091
1092 /**
1093 * es58x_handle_urb_cmd() - Handle the URB command
1094 * @es58x_dev: ES58X device.
1095 * @urb_cmd: The URB command received from the ES58X device, might not
1096 * be aligned.
1097 *
1098 * Sends the URB command to the device specific function. Manages the
1099 * errors thrown back by those functions.
1100 */
es58x_handle_urb_cmd(struct es58x_device * es58x_dev,const union es58x_urb_cmd * urb_cmd)1101 static void es58x_handle_urb_cmd(struct es58x_device *es58x_dev,
1102 const union es58x_urb_cmd *urb_cmd)
1103 {
1104 const struct es58x_operators *ops = es58x_dev->ops;
1105 size_t cmd_len;
1106 int i, ret;
1107
1108 ret = ops->handle_urb_cmd(es58x_dev, urb_cmd);
1109 switch (ret) {
1110 case 0: /* OK */
1111 return;
1112
1113 case -ENODEV:
1114 dev_err_ratelimited(es58x_dev->dev, "Device is not ready\n");
1115 break;
1116
1117 case -EINVAL:
1118 case -EMSGSIZE:
1119 case -EBADRQC:
1120 case -EBADMSG:
1121 case -ECHRNG:
1122 case -ETIMEDOUT:
1123 cmd_len = es58x_get_urb_cmd_len(es58x_dev,
1124 ops->get_msg_len(urb_cmd));
1125 dev_err(es58x_dev->dev,
1126 "ops->handle_urb_cmd() returned error %pe",
1127 ERR_PTR(ret));
1128 es58x_print_hex_dump(urb_cmd, cmd_len);
1129 break;
1130
1131 case -EFAULT:
1132 case -ENOMEM:
1133 case -EIO:
1134 default:
1135 dev_crit(es58x_dev->dev,
1136 "ops->handle_urb_cmd() returned error %pe, detaching all network devices\n",
1137 ERR_PTR(ret));
1138 for (i = 0; i < es58x_dev->num_can_ch; i++)
1139 if (es58x_dev->netdev[i])
1140 netif_device_detach(es58x_dev->netdev[i]);
1141 if (es58x_dev->ops->reset_device)
1142 es58x_dev->ops->reset_device(es58x_dev);
1143 break;
1144 }
1145
1146 /* Because the urb command could not fully be parsed,
1147 * channel_id is not confirmed. Incrementing rx_errors count
1148 * of all channels.
1149 */
1150 es58x_increment_rx_errors(es58x_dev);
1151 }
1152
1153 /**
1154 * es58x_check_rx_urb() - Check the length and format of the URB command.
1155 * @es58x_dev: ES58X device.
1156 * @urb_cmd: The URB command received from the ES58X device, might not
1157 * be aligned.
1158 * @urb_actual_len: The actual length of the URB command.
1159 *
1160 * Check if the first message of the received urb is valid, that is to
1161 * say that both the header and the length are coherent.
1162 *
1163 * Return:
1164 * the length of the first message of the URB on success.
1165 *
1166 * -ENODATA if the URB command is incomplete (in which case, the URB
1167 * command should be buffered and combined with the next URB to try to
1168 * reconstitute the URB command).
1169 *
1170 * -EOVERFLOW if the length is bigger than the maximum expected one.
1171 *
1172 * -EBADRQC if the start of frame does not match the expected value.
1173 */
es58x_check_rx_urb(struct es58x_device * es58x_dev,const union es58x_urb_cmd * urb_cmd,u32 urb_actual_len)1174 static signed int es58x_check_rx_urb(struct es58x_device *es58x_dev,
1175 const union es58x_urb_cmd *urb_cmd,
1176 u32 urb_actual_len)
1177 {
1178 const struct device *dev = es58x_dev->dev;
1179 const struct es58x_parameters *param = es58x_dev->param;
1180 u16 sof, msg_len;
1181 signed int urb_cmd_len, ret;
1182
1183 if (urb_actual_len < param->urb_cmd_header_len) {
1184 dev_vdbg(dev,
1185 "%s: Received %d bytes [%*ph]: header incomplete\n",
1186 __func__, urb_actual_len, urb_actual_len,
1187 urb_cmd->raw_cmd);
1188 return -ENODATA;
1189 }
1190
1191 sof = get_unaligned_le16(&urb_cmd->sof);
1192 if (sof != param->rx_start_of_frame) {
1193 dev_err_ratelimited(es58x_dev->dev,
1194 "%s: Expected sequence 0x%04X for start of frame but got 0x%04X.\n",
1195 __func__, param->rx_start_of_frame, sof);
1196 return -EBADRQC;
1197 }
1198
1199 msg_len = es58x_dev->ops->get_msg_len(urb_cmd);
1200 urb_cmd_len = es58x_get_urb_cmd_len(es58x_dev, msg_len);
1201 if (urb_cmd_len > param->rx_urb_cmd_max_len) {
1202 dev_err_ratelimited(es58x_dev->dev,
1203 "%s: Biggest expected size for rx urb_cmd is %u but receive a command of size %d\n",
1204 __func__,
1205 param->rx_urb_cmd_max_len, urb_cmd_len);
1206 return -EOVERFLOW;
1207 } else if (urb_actual_len < urb_cmd_len) {
1208 dev_vdbg(dev, "%s: Received %02d/%02d bytes\n",
1209 __func__, urb_actual_len, urb_cmd_len);
1210 return -ENODATA;
1211 }
1212
1213 ret = es58x_check_crc(es58x_dev, urb_cmd, urb_cmd_len);
1214 if (ret)
1215 return ret;
1216
1217 return urb_cmd_len;
1218 }
1219
1220 /**
1221 * es58x_copy_to_cmd_buf() - Copy an array to the URB command buffer.
1222 * @es58x_dev: ES58X device.
1223 * @raw_cmd: the buffer we want to copy.
1224 * @raw_cmd_len: length of @raw_cmd.
1225 *
1226 * Concatenates @raw_cmd_len bytes of @raw_cmd to the end of the URB
1227 * command buffer.
1228 *
1229 * Return: zero on success, -EMSGSIZE if not enough space is available
1230 * to do the copy.
1231 */
es58x_copy_to_cmd_buf(struct es58x_device * es58x_dev,u8 * raw_cmd,int raw_cmd_len)1232 static int es58x_copy_to_cmd_buf(struct es58x_device *es58x_dev,
1233 u8 *raw_cmd, int raw_cmd_len)
1234 {
1235 if (es58x_dev->rx_cmd_buf_len + raw_cmd_len >
1236 es58x_dev->param->rx_urb_cmd_max_len)
1237 return -EMSGSIZE;
1238
1239 memcpy(&es58x_dev->rx_cmd_buf.raw_cmd[es58x_dev->rx_cmd_buf_len],
1240 raw_cmd, raw_cmd_len);
1241 es58x_dev->rx_cmd_buf_len += raw_cmd_len;
1242
1243 return 0;
1244 }
1245
1246 /**
1247 * es58x_split_urb_try_recovery() - Try to recover bad URB sequences.
1248 * @es58x_dev: ES58X device.
1249 * @raw_cmd: pointer to the buffer we want to copy.
1250 * @raw_cmd_len: length of @raw_cmd.
1251 *
1252 * Under some rare conditions, we might get incorrect URBs from the
1253 * device. From our observations, one of the valid URB gets replaced
1254 * by one from the past. The full root cause is not identified.
1255 *
1256 * This function looks for the next start of frame in the urb buffer
1257 * in order to try to recover.
1258 *
1259 * Such behavior was not observed on the devices of the ES58X FD
1260 * family and only seems to impact the ES581.4.
1261 *
1262 * Return: the number of bytes dropped on success, -EBADMSG if recovery failed.
1263 */
es58x_split_urb_try_recovery(struct es58x_device * es58x_dev,u8 * raw_cmd,size_t raw_cmd_len)1264 static int es58x_split_urb_try_recovery(struct es58x_device *es58x_dev,
1265 u8 *raw_cmd, size_t raw_cmd_len)
1266 {
1267 union es58x_urb_cmd *urb_cmd;
1268 signed int urb_cmd_len;
1269 u16 sof;
1270 int dropped_bytes = 0;
1271
1272 es58x_increment_rx_errors(es58x_dev);
1273
1274 while (raw_cmd_len > sizeof(sof)) {
1275 urb_cmd = (union es58x_urb_cmd *)raw_cmd;
1276 sof = get_unaligned_le16(&urb_cmd->sof);
1277
1278 if (sof == es58x_dev->param->rx_start_of_frame) {
1279 urb_cmd_len = es58x_check_rx_urb(es58x_dev,
1280 urb_cmd, raw_cmd_len);
1281 if ((urb_cmd_len == -ENODATA) || urb_cmd_len > 0) {
1282 dev_info_ratelimited(es58x_dev->dev,
1283 "Recovery successful! Dropped %d bytes (urb_cmd_len: %d)\n",
1284 dropped_bytes,
1285 urb_cmd_len);
1286 return dropped_bytes;
1287 }
1288 }
1289 raw_cmd++;
1290 raw_cmd_len--;
1291 dropped_bytes++;
1292 }
1293
1294 dev_warn_ratelimited(es58x_dev->dev, "%s: Recovery failed\n", __func__);
1295 return -EBADMSG;
1296 }
1297
1298 /**
1299 * es58x_handle_incomplete_cmd() - Reconstitute an URB command from
1300 * different URB pieces.
1301 * @es58x_dev: ES58X device.
1302 * @urb: last urb buffer received.
1303 *
1304 * The device might split the URB commands in an arbitrary amount of
1305 * pieces. This function concatenates those in an URB buffer until a
1306 * full URB command is reconstituted and consume it.
1307 *
1308 * Return:
1309 * number of bytes consumed from @urb if successful.
1310 *
1311 * -ENODATA if the URB command is still incomplete.
1312 *
1313 * -EBADMSG if the URB command is incorrect.
1314 */
es58x_handle_incomplete_cmd(struct es58x_device * es58x_dev,struct urb * urb)1315 static signed int es58x_handle_incomplete_cmd(struct es58x_device *es58x_dev,
1316 struct urb *urb)
1317 {
1318 size_t cpy_len;
1319 signed int urb_cmd_len, tmp_cmd_buf_len, ret;
1320
1321 tmp_cmd_buf_len = es58x_dev->rx_cmd_buf_len;
1322 cpy_len = min_t(int, es58x_dev->param->rx_urb_cmd_max_len -
1323 es58x_dev->rx_cmd_buf_len, urb->actual_length);
1324 ret = es58x_copy_to_cmd_buf(es58x_dev, urb->transfer_buffer, cpy_len);
1325 if (ret < 0)
1326 return ret;
1327
1328 urb_cmd_len = es58x_check_rx_urb(es58x_dev, &es58x_dev->rx_cmd_buf,
1329 es58x_dev->rx_cmd_buf_len);
1330 if (urb_cmd_len == -ENODATA) {
1331 return -ENODATA;
1332 } else if (urb_cmd_len < 0) {
1333 dev_err_ratelimited(es58x_dev->dev,
1334 "Could not reconstitute incomplete command from previous URB, dropping %d bytes\n",
1335 tmp_cmd_buf_len + urb->actual_length);
1336 dev_err_ratelimited(es58x_dev->dev,
1337 "Error code: %pe, es58x_dev->rx_cmd_buf_len: %d, urb->actual_length: %u\n",
1338 ERR_PTR(urb_cmd_len),
1339 tmp_cmd_buf_len, urb->actual_length);
1340 es58x_print_hex_dump(&es58x_dev->rx_cmd_buf, tmp_cmd_buf_len);
1341 es58x_print_hex_dump(urb->transfer_buffer, urb->actual_length);
1342 return urb->actual_length;
1343 }
1344
1345 es58x_handle_urb_cmd(es58x_dev, &es58x_dev->rx_cmd_buf);
1346 return urb_cmd_len - tmp_cmd_buf_len; /* consumed length */
1347 }
1348
1349 /**
1350 * es58x_split_urb() - Cut the received URB in individual URB commands.
1351 * @es58x_dev: ES58X device.
1352 * @urb: last urb buffer received.
1353 *
1354 * The device might send urb in bulk format (i.e. several URB commands
1355 * concatenated together). This function will split all the commands
1356 * contained in the urb.
1357 *
1358 * Return:
1359 * number of bytes consumed from @urb if successful.
1360 *
1361 * -ENODATA if the URB command is incomplete.
1362 *
1363 * -EBADMSG if the URB command is incorrect.
1364 */
es58x_split_urb(struct es58x_device * es58x_dev,struct urb * urb)1365 static signed int es58x_split_urb(struct es58x_device *es58x_dev,
1366 struct urb *urb)
1367 {
1368 union es58x_urb_cmd *urb_cmd;
1369 u8 *raw_cmd = urb->transfer_buffer;
1370 s32 raw_cmd_len = urb->actual_length;
1371 int ret;
1372
1373 if (es58x_dev->rx_cmd_buf_len != 0) {
1374 ret = es58x_handle_incomplete_cmd(es58x_dev, urb);
1375 if (ret != -ENODATA)
1376 es58x_dev->rx_cmd_buf_len = 0;
1377 if (ret < 0)
1378 return ret;
1379
1380 raw_cmd += ret;
1381 raw_cmd_len -= ret;
1382 }
1383
1384 while (raw_cmd_len > 0) {
1385 if (raw_cmd[0] == ES58X_HEARTBEAT) {
1386 raw_cmd++;
1387 raw_cmd_len--;
1388 continue;
1389 }
1390 urb_cmd = (union es58x_urb_cmd *)raw_cmd;
1391 ret = es58x_check_rx_urb(es58x_dev, urb_cmd, raw_cmd_len);
1392 if (ret > 0) {
1393 es58x_handle_urb_cmd(es58x_dev, urb_cmd);
1394 } else if (ret == -ENODATA) {
1395 es58x_copy_to_cmd_buf(es58x_dev, raw_cmd, raw_cmd_len);
1396 return -ENODATA;
1397 } else if (ret < 0) {
1398 ret = es58x_split_urb_try_recovery(es58x_dev, raw_cmd,
1399 raw_cmd_len);
1400 if (ret < 0)
1401 return ret;
1402 }
1403 raw_cmd += ret;
1404 raw_cmd_len -= ret;
1405 }
1406
1407 return 0;
1408 }
1409
1410 /**
1411 * es58x_read_bulk_callback() - Callback for reading data from device.
1412 * @urb: last urb buffer received.
1413 *
1414 * This function gets eventually called each time an URB is received
1415 * from the ES58X device.
1416 *
1417 * Checks urb status, calls read function and resubmits urb read
1418 * operation.
1419 */
es58x_read_bulk_callback(struct urb * urb)1420 static void es58x_read_bulk_callback(struct urb *urb)
1421 {
1422 struct es58x_device *es58x_dev = urb->context;
1423 const struct device *dev = es58x_dev->dev;
1424 int i, ret;
1425
1426 switch (urb->status) {
1427 case 0: /* success */
1428 break;
1429
1430 case -EOVERFLOW:
1431 dev_err_ratelimited(dev, "%s: error %pe\n",
1432 __func__, ERR_PTR(urb->status));
1433 es58x_print_hex_dump_debug(urb->transfer_buffer,
1434 urb->transfer_buffer_length);
1435 goto resubmit_urb;
1436
1437 case -EPROTO:
1438 dev_warn_ratelimited(dev, "%s: error %pe. Device unplugged?\n",
1439 __func__, ERR_PTR(urb->status));
1440 goto free_urb;
1441
1442 case -ENOENT:
1443 case -EPIPE:
1444 dev_err_ratelimited(dev, "%s: error %pe\n",
1445 __func__, ERR_PTR(urb->status));
1446 goto free_urb;
1447
1448 case -ESHUTDOWN:
1449 dev_dbg_ratelimited(dev, "%s: error %pe\n",
1450 __func__, ERR_PTR(urb->status));
1451 goto free_urb;
1452
1453 default:
1454 dev_err_ratelimited(dev, "%s: error %pe\n",
1455 __func__, ERR_PTR(urb->status));
1456 goto resubmit_urb;
1457 }
1458
1459 ret = es58x_split_urb(es58x_dev, urb);
1460 if ((ret != -ENODATA) && ret < 0) {
1461 dev_err(es58x_dev->dev, "es58x_split_urb() returned error %pe",
1462 ERR_PTR(ret));
1463 es58x_print_hex_dump_debug(urb->transfer_buffer,
1464 urb->actual_length);
1465
1466 /* Because the urb command could not be parsed,
1467 * channel_id is not confirmed. Incrementing rx_errors
1468 * count of all channels.
1469 */
1470 es58x_increment_rx_errors(es58x_dev);
1471 }
1472
1473 resubmit_urb:
1474 usb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->rx_pipe,
1475 urb->transfer_buffer, urb->transfer_buffer_length,
1476 es58x_read_bulk_callback, es58x_dev);
1477
1478 ret = usb_submit_urb(urb, GFP_ATOMIC);
1479 if (ret == -ENODEV) {
1480 for (i = 0; i < es58x_dev->num_can_ch; i++)
1481 if (es58x_dev->netdev[i])
1482 netif_device_detach(es58x_dev->netdev[i]);
1483 } else if (ret)
1484 dev_err_ratelimited(dev,
1485 "Failed resubmitting read bulk urb: %pe\n",
1486 ERR_PTR(ret));
1487 return;
1488
1489 free_urb:
1490 usb_free_coherent(urb->dev, urb->transfer_buffer_length,
1491 urb->transfer_buffer, urb->transfer_dma);
1492 }
1493
1494 /**
1495 * es58x_write_bulk_callback() - Callback after writing data to the device.
1496 * @urb: urb buffer which was previously submitted.
1497 *
1498 * This function gets eventually called each time an URB was sent to
1499 * the ES58X device.
1500 *
1501 * Puts the @urb back to the urbs idle anchor and tries to restart the
1502 * network queue.
1503 */
es58x_write_bulk_callback(struct urb * urb)1504 static void es58x_write_bulk_callback(struct urb *urb)
1505 {
1506 struct net_device *netdev = urb->context;
1507 struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;
1508
1509 switch (urb->status) {
1510 case 0: /* success */
1511 break;
1512
1513 case -EOVERFLOW:
1514 if (net_ratelimit())
1515 netdev_err(netdev, "%s: error %pe\n",
1516 __func__, ERR_PTR(urb->status));
1517 es58x_print_hex_dump(urb->transfer_buffer,
1518 urb->transfer_buffer_length);
1519 break;
1520
1521 case -ENOENT:
1522 if (net_ratelimit())
1523 netdev_dbg(netdev, "%s: error %pe\n",
1524 __func__, ERR_PTR(urb->status));
1525 usb_free_coherent(urb->dev,
1526 es58x_dev->param->tx_urb_cmd_max_len,
1527 urb->transfer_buffer, urb->transfer_dma);
1528 return;
1529
1530 default:
1531 if (net_ratelimit())
1532 netdev_info(netdev, "%s: error %pe\n",
1533 __func__, ERR_PTR(urb->status));
1534 break;
1535 }
1536
1537 usb_anchor_urb(urb, &es58x_dev->tx_urbs_idle);
1538 atomic_inc(&es58x_dev->tx_urbs_idle_cnt);
1539 }
1540
1541 /**
1542 * es58x_alloc_urb() - Allocate memory for an URB and its transfer
1543 * buffer.
1544 * @es58x_dev: ES58X device.
1545 * @urb: URB to be allocated.
1546 * @buf: used to return DMA address of buffer.
1547 * @buf_len: requested buffer size.
1548 * @mem_flags: affect whether allocation may block.
1549 *
1550 * Allocates an URB and its @transfer_buffer and set its @transfer_dma
1551 * address.
1552 *
1553 * This function is used at start-up to allocate all RX URBs at once
1554 * and during run time for TX URBs.
1555 *
1556 * Return: zero on success, -ENOMEM if no memory is available.
1557 */
es58x_alloc_urb(struct es58x_device * es58x_dev,struct urb ** urb,u8 ** buf,size_t buf_len,gfp_t mem_flags)1558 static int es58x_alloc_urb(struct es58x_device *es58x_dev, struct urb **urb,
1559 u8 **buf, size_t buf_len, gfp_t mem_flags)
1560 {
1561 *urb = usb_alloc_urb(0, mem_flags);
1562 if (!*urb) {
1563 dev_err(es58x_dev->dev, "No memory left for URBs\n");
1564 return -ENOMEM;
1565 }
1566
1567 *buf = usb_alloc_coherent(es58x_dev->udev, buf_len,
1568 mem_flags, &(*urb)->transfer_dma);
1569 if (!*buf) {
1570 dev_err(es58x_dev->dev, "No memory left for USB buffer\n");
1571 usb_free_urb(*urb);
1572 return -ENOMEM;
1573 }
1574
1575 (*urb)->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1576
1577 return 0;
1578 }
1579
1580 /**
1581 * es58x_get_tx_urb() - Get an URB for transmission.
1582 * @es58x_dev: ES58X device.
1583 *
1584 * Gets an URB from the idle urbs anchor or allocate a new one if the
1585 * anchor is empty.
1586 *
1587 * If there are more than ES58X_TX_URBS_MAX in the idle anchor, do
1588 * some garbage collection. The garbage collection is done here
1589 * instead of within es58x_write_bulk_callback() because
1590 * usb_free_coherent() should not be used in IRQ context:
1591 * c.f. WARN_ON(irqs_disabled()) in dma_free_attrs().
1592 *
1593 * Return: a pointer to an URB on success, NULL if no memory is
1594 * available.
1595 */
es58x_get_tx_urb(struct es58x_device * es58x_dev)1596 static struct urb *es58x_get_tx_urb(struct es58x_device *es58x_dev)
1597 {
1598 atomic_t *idle_cnt = &es58x_dev->tx_urbs_idle_cnt;
1599 struct urb *urb = usb_get_from_anchor(&es58x_dev->tx_urbs_idle);
1600
1601 if (!urb) {
1602 size_t tx_buf_len;
1603 u8 *buf;
1604
1605 tx_buf_len = es58x_dev->param->tx_urb_cmd_max_len;
1606 if (es58x_alloc_urb(es58x_dev, &urb, &buf, tx_buf_len,
1607 GFP_ATOMIC))
1608 return NULL;
1609
1610 usb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->tx_pipe,
1611 buf, tx_buf_len, NULL, NULL);
1612 return urb;
1613 }
1614
1615 while (atomic_dec_return(idle_cnt) > ES58X_TX_URBS_MAX) {
1616 /* Garbage collector */
1617 struct urb *tmp = usb_get_from_anchor(&es58x_dev->tx_urbs_idle);
1618
1619 if (!tmp)
1620 break;
1621 usb_free_coherent(tmp->dev,
1622 es58x_dev->param->tx_urb_cmd_max_len,
1623 tmp->transfer_buffer, tmp->transfer_dma);
1624 usb_free_urb(tmp);
1625 }
1626
1627 return urb;
1628 }
1629
1630 /**
1631 * es58x_submit_urb() - Send data to the device.
1632 * @es58x_dev: ES58X device.
1633 * @urb: URB to be sent.
1634 * @netdev: CAN network device.
1635 *
1636 * Return: zero on success, errno when any error occurs.
1637 */
es58x_submit_urb(struct es58x_device * es58x_dev,struct urb * urb,struct net_device * netdev)1638 static int es58x_submit_urb(struct es58x_device *es58x_dev, struct urb *urb,
1639 struct net_device *netdev)
1640 {
1641 int ret;
1642
1643 es58x_set_crc(urb->transfer_buffer, urb->transfer_buffer_length);
1644 usb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->tx_pipe,
1645 urb->transfer_buffer, urb->transfer_buffer_length,
1646 es58x_write_bulk_callback, netdev);
1647 usb_anchor_urb(urb, &es58x_dev->tx_urbs_busy);
1648 ret = usb_submit_urb(urb, GFP_ATOMIC);
1649 if (ret) {
1650 netdev_err(netdev, "%s: USB send urb failure: %pe\n",
1651 __func__, ERR_PTR(ret));
1652 usb_unanchor_urb(urb);
1653 usb_free_coherent(urb->dev,
1654 es58x_dev->param->tx_urb_cmd_max_len,
1655 urb->transfer_buffer, urb->transfer_dma);
1656 }
1657 usb_free_urb(urb);
1658
1659 return ret;
1660 }
1661
1662 /**
1663 * es58x_send_msg() - Prepare an URB and submit it.
1664 * @es58x_dev: ES58X device.
1665 * @cmd_type: Command type.
1666 * @cmd_id: Command ID.
1667 * @msg: ES58X message to be sent.
1668 * @msg_len: Length of @msg.
1669 * @channel_idx: Index of the network device.
1670 *
1671 * Creates an URB command from a given message, sets the header and the
1672 * CRC and then submits it.
1673 *
1674 * Return: zero on success, errno when any error occurs.
1675 */
es58x_send_msg(struct es58x_device * es58x_dev,u8 cmd_type,u8 cmd_id,const void * msg,u16 msg_len,int channel_idx)1676 int es58x_send_msg(struct es58x_device *es58x_dev, u8 cmd_type, u8 cmd_id,
1677 const void *msg, u16 msg_len, int channel_idx)
1678 {
1679 struct net_device *netdev;
1680 union es58x_urb_cmd *urb_cmd;
1681 struct urb *urb;
1682 int urb_cmd_len;
1683
1684 if (channel_idx == ES58X_CHANNEL_IDX_NA)
1685 netdev = es58x_dev->netdev[0]; /* Default to first channel */
1686 else
1687 netdev = es58x_dev->netdev[channel_idx];
1688
1689 urb_cmd_len = es58x_get_urb_cmd_len(es58x_dev, msg_len);
1690 if (urb_cmd_len > es58x_dev->param->tx_urb_cmd_max_len)
1691 return -EOVERFLOW;
1692
1693 urb = es58x_get_tx_urb(es58x_dev);
1694 if (!urb)
1695 return -ENOMEM;
1696
1697 urb_cmd = urb->transfer_buffer;
1698 es58x_dev->ops->fill_urb_header(urb_cmd, cmd_type, cmd_id,
1699 channel_idx, msg_len);
1700 memcpy(&urb_cmd->raw_cmd[es58x_dev->param->urb_cmd_header_len],
1701 msg, msg_len);
1702 urb->transfer_buffer_length = urb_cmd_len;
1703
1704 return es58x_submit_urb(es58x_dev, urb, netdev);
1705 }
1706
1707 /**
1708 * es58x_alloc_rx_urbs() - Allocate RX URBs.
1709 * @es58x_dev: ES58X device.
1710 *
1711 * Allocate URBs for reception and anchor them.
1712 *
1713 * Return: zero on success, errno when any error occurs.
1714 */
es58x_alloc_rx_urbs(struct es58x_device * es58x_dev)1715 static int es58x_alloc_rx_urbs(struct es58x_device *es58x_dev)
1716 {
1717 const struct device *dev = es58x_dev->dev;
1718 const struct es58x_parameters *param = es58x_dev->param;
1719 size_t rx_buf_len = es58x_dev->rx_max_packet_size;
1720 struct urb *urb;
1721 u8 *buf;
1722 int i;
1723 int ret = -EINVAL;
1724
1725 for (i = 0; i < param->rx_urb_max; i++) {
1726 ret = es58x_alloc_urb(es58x_dev, &urb, &buf, rx_buf_len,
1727 GFP_KERNEL);
1728 if (ret)
1729 break;
1730
1731 usb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->rx_pipe,
1732 buf, rx_buf_len, es58x_read_bulk_callback,
1733 es58x_dev);
1734 usb_anchor_urb(urb, &es58x_dev->rx_urbs);
1735
1736 ret = usb_submit_urb(urb, GFP_KERNEL);
1737 if (ret) {
1738 usb_unanchor_urb(urb);
1739 usb_free_coherent(es58x_dev->udev, rx_buf_len,
1740 buf, urb->transfer_dma);
1741 usb_free_urb(urb);
1742 break;
1743 }
1744 usb_free_urb(urb);
1745 }
1746
1747 if (i == 0) {
1748 dev_err(dev, "%s: Could not setup any rx URBs\n", __func__);
1749 return ret;
1750 }
1751 dev_dbg(dev, "%s: Allocated %d rx URBs each of size %zu\n",
1752 __func__, i, rx_buf_len);
1753
1754 return ret;
1755 }
1756
1757 /**
1758 * es58x_free_urbs() - Free all the TX and RX URBs.
1759 * @es58x_dev: ES58X device.
1760 */
es58x_free_urbs(struct es58x_device * es58x_dev)1761 static void es58x_free_urbs(struct es58x_device *es58x_dev)
1762 {
1763 struct urb *urb;
1764
1765 if (!usb_wait_anchor_empty_timeout(&es58x_dev->tx_urbs_busy, 1000)) {
1766 dev_err(es58x_dev->dev, "%s: Timeout, some TX urbs still remain\n",
1767 __func__);
1768 usb_kill_anchored_urbs(&es58x_dev->tx_urbs_busy);
1769 }
1770
1771 while ((urb = usb_get_from_anchor(&es58x_dev->tx_urbs_idle)) != NULL) {
1772 usb_free_coherent(urb->dev, es58x_dev->param->tx_urb_cmd_max_len,
1773 urb->transfer_buffer, urb->transfer_dma);
1774 usb_free_urb(urb);
1775 atomic_dec(&es58x_dev->tx_urbs_idle_cnt);
1776 }
1777 if (atomic_read(&es58x_dev->tx_urbs_idle_cnt))
1778 dev_err(es58x_dev->dev,
1779 "All idle urbs were freed but tx_urb_idle_cnt is %d\n",
1780 atomic_read(&es58x_dev->tx_urbs_idle_cnt));
1781
1782 usb_kill_anchored_urbs(&es58x_dev->rx_urbs);
1783 }
1784
1785 /**
1786 * es58x_open() - Enable the network device.
1787 * @netdev: CAN network device.
1788 *
1789 * Called when the network transitions to the up state. Allocate the
1790 * URB resources if needed and open the channel.
1791 *
1792 * Return: zero on success, errno when any error occurs.
1793 */
es58x_open(struct net_device * netdev)1794 static int es58x_open(struct net_device *netdev)
1795 {
1796 struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;
1797 int ret;
1798
1799 if (atomic_inc_return(&es58x_dev->opened_channel_cnt) == 1) {
1800 ret = es58x_alloc_rx_urbs(es58x_dev);
1801 if (ret)
1802 return ret;
1803
1804 ret = es58x_set_realtime_diff_ns(es58x_dev);
1805 if (ret)
1806 goto free_urbs;
1807 }
1808
1809 ret = open_candev(netdev);
1810 if (ret)
1811 goto free_urbs;
1812
1813 ret = es58x_dev->ops->enable_channel(es58x_priv(netdev));
1814 if (ret)
1815 goto free_urbs;
1816
1817 netif_start_queue(netdev);
1818
1819 return ret;
1820
1821 free_urbs:
1822 if (atomic_dec_and_test(&es58x_dev->opened_channel_cnt))
1823 es58x_free_urbs(es58x_dev);
1824 netdev_err(netdev, "%s: Could not open the network device: %pe\n",
1825 __func__, ERR_PTR(ret));
1826
1827 return ret;
1828 }
1829
1830 /**
1831 * es58x_stop() - Disable the network device.
1832 * @netdev: CAN network device.
1833 *
1834 * Called when the network transitions to the down state. If all the
1835 * channels of the device are closed, free the URB resources which are
1836 * not needed anymore.
1837 *
1838 * Return: zero on success, errno when any error occurs.
1839 */
es58x_stop(struct net_device * netdev)1840 static int es58x_stop(struct net_device *netdev)
1841 {
1842 struct es58x_priv *priv = es58x_priv(netdev);
1843 struct es58x_device *es58x_dev = priv->es58x_dev;
1844 int ret;
1845
1846 netif_stop_queue(netdev);
1847 ret = es58x_dev->ops->disable_channel(priv);
1848 if (ret)
1849 return ret;
1850
1851 priv->can.state = CAN_STATE_STOPPED;
1852 es58x_can_reset_echo_fifo(netdev);
1853 close_candev(netdev);
1854
1855 es58x_flush_pending_tx_msg(netdev);
1856
1857 if (atomic_dec_and_test(&es58x_dev->opened_channel_cnt))
1858 es58x_free_urbs(es58x_dev);
1859
1860 return 0;
1861 }
1862
1863 /**
1864 * es58x_xmit_commit() - Send the bulk urb.
1865 * @netdev: CAN network device.
1866 *
1867 * Do the bulk send. This function should be called only once by bulk
1868 * transmission.
1869 *
1870 * Return: zero on success, errno when any error occurs.
1871 */
es58x_xmit_commit(struct net_device * netdev)1872 static int es58x_xmit_commit(struct net_device *netdev)
1873 {
1874 struct es58x_priv *priv = es58x_priv(netdev);
1875 int ret;
1876
1877 if (!es58x_is_can_state_active(netdev))
1878 return -ENETDOWN;
1879
1880 if (es58x_is_echo_skb_threshold_reached(priv))
1881 netif_stop_queue(netdev);
1882
1883 ret = es58x_submit_urb(priv->es58x_dev, priv->tx_urb, netdev);
1884 if (ret == 0)
1885 priv->tx_urb = NULL;
1886
1887 return ret;
1888 }
1889
1890 /**
1891 * es58x_xmit_more() - Can we put more packets?
1892 * @priv: ES58X private parameters related to the network device.
1893 *
1894 * Return: true if we can put more, false if it is time to send.
1895 */
es58x_xmit_more(struct es58x_priv * priv)1896 static bool es58x_xmit_more(struct es58x_priv *priv)
1897 {
1898 unsigned int free_slots =
1899 priv->can.echo_skb_max - (priv->tx_head - priv->tx_tail);
1900
1901 return netdev_xmit_more() && free_slots > 0 &&
1902 priv->tx_can_msg_cnt < priv->es58x_dev->param->tx_bulk_max;
1903 }
1904
1905 /**
1906 * es58x_start_xmit() - Transmit an skb.
1907 * @skb: socket buffer of a CAN message.
1908 * @netdev: CAN network device.
1909 *
1910 * Called when a packet needs to be transmitted.
1911 *
1912 * This function relies on Byte Queue Limits (BQL). The main benefit
1913 * is to increase the throughput by allowing bulk transfers
1914 * (c.f. xmit_more flag).
1915 *
1916 * Queues up to tx_bulk_max messages in &tx_urb buffer and does
1917 * a bulk send of all messages in one single URB.
1918 *
1919 * Return: NETDEV_TX_OK regardless of if we could transmit the @skb or
1920 * had to drop it.
1921 */
es58x_start_xmit(struct sk_buff * skb,struct net_device * netdev)1922 static netdev_tx_t es58x_start_xmit(struct sk_buff *skb,
1923 struct net_device *netdev)
1924 {
1925 struct es58x_priv *priv = es58x_priv(netdev);
1926 struct es58x_device *es58x_dev = priv->es58x_dev;
1927 unsigned int frame_len;
1928 int ret;
1929
1930 if (can_dropped_invalid_skb(netdev, skb)) {
1931 if (priv->tx_urb)
1932 goto xmit_commit;
1933 return NETDEV_TX_OK;
1934 }
1935
1936 if (priv->tx_urb && priv->tx_can_msg_is_fd != can_is_canfd_skb(skb)) {
1937 /* Can not do bulk send with mixed CAN and CAN FD frames. */
1938 ret = es58x_xmit_commit(netdev);
1939 if (ret)
1940 goto drop_skb;
1941 }
1942
1943 if (!priv->tx_urb) {
1944 priv->tx_urb = es58x_get_tx_urb(es58x_dev);
1945 if (!priv->tx_urb) {
1946 ret = -ENOMEM;
1947 goto drop_skb;
1948 }
1949 priv->tx_can_msg_cnt = 0;
1950 priv->tx_can_msg_is_fd = can_is_canfd_skb(skb);
1951 }
1952
1953 ret = es58x_dev->ops->tx_can_msg(priv, skb);
1954 if (ret)
1955 goto drop_skb;
1956
1957 frame_len = can_skb_get_frame_len(skb);
1958 ret = can_put_echo_skb(skb, netdev,
1959 priv->tx_head & es58x_dev->param->fifo_mask,
1960 frame_len);
1961 if (ret)
1962 goto xmit_failure;
1963 netdev_sent_queue(netdev, frame_len);
1964
1965 priv->tx_head++;
1966 priv->tx_can_msg_cnt++;
1967
1968 xmit_commit:
1969 if (!es58x_xmit_more(priv)) {
1970 ret = es58x_xmit_commit(netdev);
1971 if (ret)
1972 goto xmit_failure;
1973 }
1974
1975 return NETDEV_TX_OK;
1976
1977 drop_skb:
1978 dev_kfree_skb(skb);
1979 netdev->stats.tx_dropped++;
1980 xmit_failure:
1981 netdev_warn(netdev, "%s: send message failure: %pe\n",
1982 __func__, ERR_PTR(ret));
1983 netdev->stats.tx_errors++;
1984 es58x_flush_pending_tx_msg(netdev);
1985 return NETDEV_TX_OK;
1986 }
1987
1988 static const struct net_device_ops es58x_netdev_ops = {
1989 .ndo_open = es58x_open,
1990 .ndo_stop = es58x_stop,
1991 .ndo_start_xmit = es58x_start_xmit
1992 };
1993
1994 /**
1995 * es58x_set_mode() - Change network device mode.
1996 * @netdev: CAN network device.
1997 * @mode: either %CAN_MODE_START, %CAN_MODE_STOP or %CAN_MODE_SLEEP
1998 *
1999 * Currently, this function is only used to stop and restart the
2000 * channel during a bus off event (c.f. es58x_rx_err_msg() and
2001 * drivers/net/can/dev.c:can_restart() which are the two only
2002 * callers).
2003 *
2004 * Return: zero on success, errno when any error occurs.
2005 */
es58x_set_mode(struct net_device * netdev,enum can_mode mode)2006 static int es58x_set_mode(struct net_device *netdev, enum can_mode mode)
2007 {
2008 struct es58x_priv *priv = es58x_priv(netdev);
2009
2010 switch (mode) {
2011 case CAN_MODE_START:
2012 switch (priv->can.state) {
2013 case CAN_STATE_BUS_OFF:
2014 return priv->es58x_dev->ops->enable_channel(priv);
2015
2016 case CAN_STATE_STOPPED:
2017 return es58x_open(netdev);
2018
2019 case CAN_STATE_ERROR_ACTIVE:
2020 case CAN_STATE_ERROR_WARNING:
2021 case CAN_STATE_ERROR_PASSIVE:
2022 default:
2023 return 0;
2024 }
2025
2026 case CAN_MODE_STOP:
2027 switch (priv->can.state) {
2028 case CAN_STATE_STOPPED:
2029 return 0;
2030
2031 case CAN_STATE_ERROR_ACTIVE:
2032 case CAN_STATE_ERROR_WARNING:
2033 case CAN_STATE_ERROR_PASSIVE:
2034 case CAN_STATE_BUS_OFF:
2035 default:
2036 return priv->es58x_dev->ops->disable_channel(priv);
2037 }
2038
2039 case CAN_MODE_SLEEP:
2040 default:
2041 return -EOPNOTSUPP;
2042 }
2043 }
2044
2045 /**
2046 * es58x_init_priv() - Initialize private parameters.
2047 * @es58x_dev: ES58X device.
2048 * @priv: ES58X private parameters related to the network device.
2049 * @channel_idx: Index of the network device.
2050 */
es58x_init_priv(struct es58x_device * es58x_dev,struct es58x_priv * priv,int channel_idx)2051 static void es58x_init_priv(struct es58x_device *es58x_dev,
2052 struct es58x_priv *priv, int channel_idx)
2053 {
2054 const struct es58x_parameters *param = es58x_dev->param;
2055 struct can_priv *can = &priv->can;
2056
2057 priv->es58x_dev = es58x_dev;
2058 priv->channel_idx = channel_idx;
2059 priv->tx_urb = NULL;
2060 priv->tx_can_msg_cnt = 0;
2061
2062 can->bittiming_const = param->bittiming_const;
2063 if (param->ctrlmode_supported & CAN_CTRLMODE_FD) {
2064 can->data_bittiming_const = param->data_bittiming_const;
2065 can->tdc_const = param->tdc_const;
2066 }
2067 can->bitrate_max = param->bitrate_max;
2068 can->clock = param->clock;
2069 can->state = CAN_STATE_STOPPED;
2070 can->ctrlmode_supported = param->ctrlmode_supported;
2071 can->do_set_mode = es58x_set_mode;
2072 }
2073
2074 /**
2075 * es58x_init_netdev() - Initialize the network device.
2076 * @es58x_dev: ES58X device.
2077 * @channel_idx: Index of the network device.
2078 *
2079 * Return: zero on success, errno when any error occurs.
2080 */
es58x_init_netdev(struct es58x_device * es58x_dev,int channel_idx)2081 static int es58x_init_netdev(struct es58x_device *es58x_dev, int channel_idx)
2082 {
2083 struct net_device *netdev;
2084 struct device *dev = es58x_dev->dev;
2085 int ret;
2086
2087 netdev = alloc_candev(sizeof(struct es58x_priv),
2088 es58x_dev->param->fifo_mask + 1);
2089 if (!netdev) {
2090 dev_err(dev, "Could not allocate candev\n");
2091 return -ENOMEM;
2092 }
2093 SET_NETDEV_DEV(netdev, dev);
2094 es58x_dev->netdev[channel_idx] = netdev;
2095 es58x_init_priv(es58x_dev, es58x_priv(netdev), channel_idx);
2096
2097 netdev->netdev_ops = &es58x_netdev_ops;
2098 netdev->flags |= IFF_ECHO; /* We support local echo */
2099
2100 ret = register_candev(netdev);
2101 if (ret)
2102 return ret;
2103
2104 netdev_queue_set_dql_min_limit(netdev_get_tx_queue(netdev, 0),
2105 es58x_dev->param->dql_min_limit);
2106
2107 return ret;
2108 }
2109
2110 /**
2111 * es58x_get_product_info() - Get the product information and print them.
2112 * @es58x_dev: ES58X device.
2113 *
2114 * Do a synchronous call to get the product information.
2115 *
2116 * Return: zero on success, errno when any error occurs.
2117 */
es58x_get_product_info(struct es58x_device * es58x_dev)2118 static int es58x_get_product_info(struct es58x_device *es58x_dev)
2119 {
2120 struct usb_device *udev = es58x_dev->udev;
2121 const int es58x_prod_info_idx = 6;
2122 /* Empirical tests show a prod_info length of maximum 83,
2123 * below should be more than enough.
2124 */
2125 const size_t prod_info_len = 127;
2126 char *prod_info;
2127 int ret;
2128
2129 prod_info = kmalloc(prod_info_len, GFP_KERNEL);
2130 if (!prod_info)
2131 return -ENOMEM;
2132
2133 ret = usb_string(udev, es58x_prod_info_idx, prod_info, prod_info_len);
2134 if (ret < 0) {
2135 dev_err(es58x_dev->dev,
2136 "%s: Could not read the product info: %pe\n",
2137 __func__, ERR_PTR(ret));
2138 goto out_free;
2139 }
2140 if (ret >= prod_info_len - 1) {
2141 dev_warn(es58x_dev->dev,
2142 "%s: Buffer is too small, result might be truncated\n",
2143 __func__);
2144 }
2145 dev_info(es58x_dev->dev, "Product info: %s\n", prod_info);
2146
2147 out_free:
2148 kfree(prod_info);
2149 return ret < 0 ? ret : 0;
2150 }
2151
2152 /**
2153 * es58x_init_es58x_dev() - Initialize the ES58X device.
2154 * @intf: USB interface.
2155 * @p_es58x_dev: pointer to the address of the ES58X device.
2156 * @driver_info: Quirks of the device.
2157 *
2158 * Return: zero on success, errno when any error occurs.
2159 */
es58x_init_es58x_dev(struct usb_interface * intf,struct es58x_device ** p_es58x_dev,kernel_ulong_t driver_info)2160 static int es58x_init_es58x_dev(struct usb_interface *intf,
2161 struct es58x_device **p_es58x_dev,
2162 kernel_ulong_t driver_info)
2163 {
2164 struct device *dev = &intf->dev;
2165 struct es58x_device *es58x_dev;
2166 const struct es58x_parameters *param;
2167 const struct es58x_operators *ops;
2168 struct usb_device *udev = interface_to_usbdev(intf);
2169 struct usb_endpoint_descriptor *ep_in, *ep_out;
2170 int ret;
2171
2172 dev_info(dev,
2173 "Starting %s %s (Serial Number %s) driver version %s\n",
2174 udev->manufacturer, udev->product, udev->serial, DRV_VERSION);
2175
2176 ret = usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out,
2177 NULL, NULL);
2178 if (ret)
2179 return ret;
2180
2181 if (driver_info & ES58X_FD_FAMILY) {
2182 param = &es58x_fd_param;
2183 ops = &es58x_fd_ops;
2184 } else {
2185 param = &es581_4_param;
2186 ops = &es581_4_ops;
2187 }
2188
2189 es58x_dev = kzalloc(es58x_sizeof_es58x_device(param), GFP_KERNEL);
2190 if (!es58x_dev)
2191 return -ENOMEM;
2192
2193 es58x_dev->param = param;
2194 es58x_dev->ops = ops;
2195 es58x_dev->dev = dev;
2196 es58x_dev->udev = udev;
2197
2198 if (driver_info & ES58X_DUAL_CHANNEL)
2199 es58x_dev->num_can_ch = 2;
2200 else
2201 es58x_dev->num_can_ch = 1;
2202
2203 init_usb_anchor(&es58x_dev->rx_urbs);
2204 init_usb_anchor(&es58x_dev->tx_urbs_idle);
2205 init_usb_anchor(&es58x_dev->tx_urbs_busy);
2206 atomic_set(&es58x_dev->tx_urbs_idle_cnt, 0);
2207 atomic_set(&es58x_dev->opened_channel_cnt, 0);
2208 usb_set_intfdata(intf, es58x_dev);
2209
2210 es58x_dev->rx_pipe = usb_rcvbulkpipe(es58x_dev->udev,
2211 ep_in->bEndpointAddress);
2212 es58x_dev->tx_pipe = usb_sndbulkpipe(es58x_dev->udev,
2213 ep_out->bEndpointAddress);
2214 es58x_dev->rx_max_packet_size = le16_to_cpu(ep_in->wMaxPacketSize);
2215
2216 *p_es58x_dev = es58x_dev;
2217
2218 return 0;
2219 }
2220
2221 /**
2222 * es58x_probe() - Initialize the USB device.
2223 * @intf: USB interface.
2224 * @id: USB device ID.
2225 *
2226 * Return: zero on success, -ENODEV if the interface is not supported
2227 * or errno when any other error occurs.
2228 */
es58x_probe(struct usb_interface * intf,const struct usb_device_id * id)2229 static int es58x_probe(struct usb_interface *intf,
2230 const struct usb_device_id *id)
2231 {
2232 struct es58x_device *es58x_dev;
2233 int ch_idx, ret;
2234
2235 ret = es58x_init_es58x_dev(intf, &es58x_dev, id->driver_info);
2236 if (ret)
2237 return ret;
2238
2239 ret = es58x_get_product_info(es58x_dev);
2240 if (ret)
2241 goto cleanup_es58x_dev;
2242
2243 for (ch_idx = 0; ch_idx < es58x_dev->num_can_ch; ch_idx++) {
2244 ret = es58x_init_netdev(es58x_dev, ch_idx);
2245 if (ret)
2246 goto cleanup_candev;
2247 }
2248
2249 return ret;
2250
2251 cleanup_candev:
2252 for (ch_idx = 0; ch_idx < es58x_dev->num_can_ch; ch_idx++)
2253 if (es58x_dev->netdev[ch_idx]) {
2254 unregister_candev(es58x_dev->netdev[ch_idx]);
2255 free_candev(es58x_dev->netdev[ch_idx]);
2256 }
2257 cleanup_es58x_dev:
2258 kfree(es58x_dev);
2259
2260 return ret;
2261 }
2262
2263 /**
2264 * es58x_disconnect() - Disconnect the USB device.
2265 * @intf: USB interface
2266 *
2267 * Called by the usb core when driver is unloaded or device is
2268 * removed.
2269 */
es58x_disconnect(struct usb_interface * intf)2270 static void es58x_disconnect(struct usb_interface *intf)
2271 {
2272 struct es58x_device *es58x_dev = usb_get_intfdata(intf);
2273 struct net_device *netdev;
2274 int i;
2275
2276 dev_info(&intf->dev, "Disconnecting %s %s\n",
2277 es58x_dev->udev->manufacturer, es58x_dev->udev->product);
2278
2279 for (i = 0; i < es58x_dev->num_can_ch; i++) {
2280 netdev = es58x_dev->netdev[i];
2281 if (!netdev)
2282 continue;
2283 unregister_candev(netdev);
2284 es58x_dev->netdev[i] = NULL;
2285 free_candev(netdev);
2286 }
2287
2288 es58x_free_urbs(es58x_dev);
2289
2290 kfree(es58x_dev);
2291 usb_set_intfdata(intf, NULL);
2292 }
2293
2294 static struct usb_driver es58x_driver = {
2295 .name = ES58X_MODULE_NAME,
2296 .probe = es58x_probe,
2297 .disconnect = es58x_disconnect,
2298 .id_table = es58x_id_table
2299 };
2300
2301 module_usb_driver(es58x_driver);
2302