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