1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | |
3 | /* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces. |
4 | * |
5 | * File es58x_core.h: All common definitions and declarations. |
6 | * |
7 | * Copyright (c) 2019 Robert Bosch Engineering and Business Solutions. All rights reserved. |
8 | * Copyright (c) 2020 ETAS K.K.. All rights reserved. |
9 | * Copyright (c) 2020-2022 Vincent Mailhol <mailhol.vincent@wanadoo.fr> |
10 | */ |
11 | |
12 | #ifndef __ES58X_COMMON_H__ |
13 | #define __ES58X_COMMON_H__ |
14 | |
15 | #include <linux/can.h> |
16 | #include <linux/can/dev.h> |
17 | #include <linux/netdevice.h> |
18 | #include <linux/types.h> |
19 | #include <linux/usb.h> |
20 | #include <net/devlink.h> |
21 | |
22 | #include "es581_4.h" |
23 | #include "es58x_fd.h" |
24 | |
25 | /* Driver constants */ |
26 | #define ES58X_RX_URBS_MAX 5 /* Empirical value */ |
27 | #define ES58X_TX_URBS_MAX 6 /* Empirical value */ |
28 | |
29 | #define ES58X_MAX(param) \ |
30 | (ES581_4_##param > ES58X_FD_##param ? \ |
31 | ES581_4_##param : ES58X_FD_##param) |
32 | #define ES58X_TX_BULK_MAX ES58X_MAX(TX_BULK_MAX) |
33 | #define ES58X_RX_BULK_MAX ES58X_MAX(RX_BULK_MAX) |
34 | #define ES58X_ECHO_BULK_MAX ES58X_MAX(ECHO_BULK_MAX) |
35 | #define ES58X_NUM_CAN_CH_MAX ES58X_MAX(NUM_CAN_CH) |
36 | |
37 | /* Use this when channel index is irrelevant (e.g. device |
38 | * timestamp). |
39 | */ |
40 | #define ES58X_CHANNEL_IDX_NA 0xFF |
41 | #define ES58X_EMPTY_MSG NULL |
42 | |
43 | /* Threshold on consecutive CAN_STATE_ERROR_PASSIVE. If we receive |
44 | * ES58X_CONSECUTIVE_ERR_PASSIVE_MAX times the event |
45 | * ES58X_ERR_CRTL_PASSIVE in a row without any successful RX or TX, |
46 | * we force the device to switch to CAN_STATE_BUS_OFF state. |
47 | */ |
48 | #define ES58X_CONSECUTIVE_ERR_PASSIVE_MAX 254 |
49 | |
50 | /* A magic number sent by the ES581.4 to inform it is alive. */ |
51 | #define ES58X_HEARTBEAT 0x11 |
52 | |
53 | /** |
54 | * enum es58x_driver_info - Quirks of the device. |
55 | * @ES58X_DUAL_CHANNEL: Device has two CAN channels. If this flag is |
56 | * not set, it is implied that the device has only one CAN |
57 | * channel. |
58 | * @ES58X_FD_FAMILY: Device is CAN-FD capable. If this flag is not |
59 | * set, the device only supports classical CAN. |
60 | */ |
61 | enum es58x_driver_info { |
62 | ES58X_DUAL_CHANNEL = BIT(0), |
63 | ES58X_FD_FAMILY = BIT(1) |
64 | }; |
65 | |
66 | enum es58x_echo { |
67 | ES58X_ECHO_OFF = 0, |
68 | ES58X_ECHO_ON = 1 |
69 | }; |
70 | |
71 | /** |
72 | * enum es58x_physical_layer - Type of the physical layer. |
73 | * @ES58X_PHYSICAL_LAYER_HIGH_SPEED: High-speed CAN (c.f. ISO |
74 | * 11898-2). |
75 | * |
76 | * Some products of the ETAS portfolio also support low-speed CAN |
77 | * (c.f. ISO 11898-3). However, all the devices in scope of this |
78 | * driver do not support the option, thus, the enum has only one |
79 | * member. |
80 | */ |
81 | enum es58x_physical_layer { |
82 | ES58X_PHYSICAL_LAYER_HIGH_SPEED = 1 |
83 | }; |
84 | |
85 | enum es58x_samples_per_bit { |
86 | ES58X_SAMPLES_PER_BIT_ONE = 1, |
87 | ES58X_SAMPLES_PER_BIT_THREE = 2 |
88 | }; |
89 | |
90 | /** |
91 | * enum es58x_sync_edge - Synchronization method. |
92 | * @ES58X_SYNC_EDGE_SINGLE: ISO CAN specification defines the use of a |
93 | * single edge synchronization. The synchronization should be |
94 | * done on recessive to dominant level change. |
95 | * |
96 | * For information, ES582.1 and ES584.1 also support a double |
97 | * synchronization, requiring both recessive to dominant then dominant |
98 | * to recessive level change. However, this is not supported in |
99 | * SocketCAN framework, thus, the enum has only one member. |
100 | */ |
101 | enum es58x_sync_edge { |
102 | ES58X_SYNC_EDGE_SINGLE = 1 |
103 | }; |
104 | |
105 | /** |
106 | * enum es58x_flag - CAN flags for RX/TX messages. |
107 | * @ES58X_FLAG_EFF: Extended Frame Format (EFF). |
108 | * @ES58X_FLAG_RTR: Remote Transmission Request (RTR). |
109 | * @ES58X_FLAG_FD_BRS: Bit rate switch (BRS): second bitrate for |
110 | * payload data. |
111 | * @ES58X_FLAG_FD_ESI: Error State Indicator (ESI): tell if the |
112 | * transmitting node is in error passive mode. |
113 | * @ES58X_FLAG_FD_DATA: CAN FD frame. |
114 | */ |
115 | enum es58x_flag { |
116 | ES58X_FLAG_EFF = BIT(0), |
117 | ES58X_FLAG_RTR = BIT(1), |
118 | ES58X_FLAG_FD_BRS = BIT(3), |
119 | ES58X_FLAG_FD_ESI = BIT(5), |
120 | ES58X_FLAG_FD_DATA = BIT(6) |
121 | }; |
122 | |
123 | /** |
124 | * enum es58x_err - CAN error detection. |
125 | * @ES58X_ERR_OK: No errors. |
126 | * @ES58X_ERR_PROT_STUFF: Bit stuffing error: more than 5 consecutive |
127 | * equal bits. |
128 | * @ES58X_ERR_PROT_FORM: Frame format error. |
129 | * @ES58X_ERR_ACK: Received no ACK on transmission. |
130 | * @ES58X_ERR_PROT_BIT: Single bit error. |
131 | * @ES58X_ERR_PROT_CRC: Incorrect 15, 17 or 21 bits CRC. |
132 | * @ES58X_ERR_PROT_BIT1: Unable to send recessive bit: tried to send |
133 | * recessive bit 1 but monitored dominant bit 0. |
134 | * @ES58X_ERR_PROT_BIT0: Unable to send dominant bit: tried to send |
135 | * dominant bit 0 but monitored recessive bit 1. |
136 | * @ES58X_ERR_PROT_OVERLOAD: Bus overload. |
137 | * @ES58X_ERR_PROT_UNSPEC: Unspecified. |
138 | * |
139 | * Please refer to ISO 11898-1:2015, section 10.11 "Error detection" |
140 | * and section 10.13 "Overload signaling" for additional details. |
141 | */ |
142 | enum es58x_err { |
143 | ES58X_ERR_OK = 0, |
144 | ES58X_ERR_PROT_STUFF = BIT(0), |
145 | ES58X_ERR_PROT_FORM = BIT(1), |
146 | ES58X_ERR_ACK = BIT(2), |
147 | ES58X_ERR_PROT_BIT = BIT(3), |
148 | ES58X_ERR_PROT_CRC = BIT(4), |
149 | ES58X_ERR_PROT_BIT1 = BIT(5), |
150 | ES58X_ERR_PROT_BIT0 = BIT(6), |
151 | ES58X_ERR_PROT_OVERLOAD = BIT(7), |
152 | ES58X_ERR_PROT_UNSPEC = BIT(31) |
153 | }; |
154 | |
155 | /** |
156 | * enum es58x_event - CAN error codes returned by the device. |
157 | * @ES58X_EVENT_OK: No errors. |
158 | * @ES58X_EVENT_CRTL_ACTIVE: Active state: both TR and RX error count |
159 | * is less than 128. |
160 | * @ES58X_EVENT_CRTL_PASSIVE: Passive state: either TX or RX error |
161 | * count is greater than 127. |
162 | * @ES58X_EVENT_CRTL_WARNING: Warning state: either TX or RX error |
163 | * count is greater than 96. |
164 | * @ES58X_EVENT_BUSOFF: Bus off. |
165 | * @ES58X_EVENT_SINGLE_WIRE: Lost connection on either CAN high or CAN |
166 | * low. |
167 | * |
168 | * Please refer to ISO 11898-1:2015, section 12.1.4 "Rules of fault |
169 | * confinement" for additional details. |
170 | */ |
171 | enum es58x_event { |
172 | ES58X_EVENT_OK = 0, |
173 | ES58X_EVENT_CRTL_ACTIVE = BIT(0), |
174 | ES58X_EVENT_CRTL_PASSIVE = BIT(1), |
175 | ES58X_EVENT_CRTL_WARNING = BIT(2), |
176 | ES58X_EVENT_BUSOFF = BIT(3), |
177 | ES58X_EVENT_SINGLE_WIRE = BIT(4) |
178 | }; |
179 | |
180 | /* enum es58x_ret_u8 - Device return error codes, 8 bit format. |
181 | * |
182 | * Specific to ES581.4. |
183 | */ |
184 | enum es58x_ret_u8 { |
185 | ES58X_RET_U8_OK = 0x00, |
186 | ES58X_RET_U8_ERR_UNSPECIFIED_FAILURE = 0x80, |
187 | ES58X_RET_U8_ERR_NO_MEM = 0x81, |
188 | ES58X_RET_U8_ERR_BAD_CRC = 0x99 |
189 | }; |
190 | |
191 | /* enum es58x_ret_u32 - Device return error codes, 32 bit format. |
192 | */ |
193 | enum es58x_ret_u32 { |
194 | ES58X_RET_U32_OK = 0x00000000UL, |
195 | ES58X_RET_U32_ERR_UNSPECIFIED_FAILURE = 0x80000000UL, |
196 | ES58X_RET_U32_ERR_NO_MEM = 0x80004001UL, |
197 | ES58X_RET_U32_WARN_PARAM_ADJUSTED = 0x40004000UL, |
198 | ES58X_RET_U32_WARN_TX_MAYBE_REORDER = 0x40004001UL, |
199 | ES58X_RET_U32_ERR_TIMEDOUT = 0x80000008UL, |
200 | ES58X_RET_U32_ERR_FIFO_FULL = 0x80003002UL, |
201 | ES58X_RET_U32_ERR_BAD_CONFIG = 0x80004000UL, |
202 | ES58X_RET_U32_ERR_NO_RESOURCE = 0x80004002UL |
203 | }; |
204 | |
205 | /* enum es58x_ret_type - Type of the command returned by the ES58X |
206 | * device. |
207 | */ |
208 | enum es58x_ret_type { |
209 | ES58X_RET_TYPE_SET_BITTIMING, |
210 | ES58X_RET_TYPE_ENABLE_CHANNEL, |
211 | ES58X_RET_TYPE_DISABLE_CHANNEL, |
212 | ES58X_RET_TYPE_TX_MSG, |
213 | ES58X_RET_TYPE_RESET_RX, |
214 | ES58X_RET_TYPE_RESET_TX, |
215 | ES58X_RET_TYPE_DEVICE_ERR |
216 | }; |
217 | |
218 | union es58x_urb_cmd { |
219 | struct es581_4_urb_cmd es581_4_urb_cmd; |
220 | struct es58x_fd_urb_cmd es58x_fd_urb_cmd; |
221 | struct { /* Common header parts of all variants */ |
222 | __le16 sof; |
223 | u8 cmd_type; |
224 | u8 cmd_id; |
225 | } __packed; |
226 | DECLARE_FLEX_ARRAY(u8, raw_cmd); |
227 | }; |
228 | |
229 | /** |
230 | * struct es58x_priv - All information specific to a CAN channel. |
231 | * @can: struct can_priv must be the first member (Socket CAN relies |
232 | * on the fact that function netdev_priv() returns a pointer to |
233 | * a struct can_priv). |
234 | * @devlink_port: devlink instance for the network interface. |
235 | * @es58x_dev: pointer to the corresponding ES58X device. |
236 | * @tx_urb: Used as a buffer to concatenate the TX messages and to do |
237 | * a bulk send. Please refer to es58x_start_xmit() for more |
238 | * details. |
239 | * @tx_tail: Index of the oldest packet still pending for |
240 | * completion. @tx_tail & echo_skb_mask represents the beginning |
241 | * of the echo skb FIFO, i.e. index of the first element. |
242 | * @tx_head: Index of the next packet to be sent to the |
243 | * device. @tx_head & echo_skb_mask represents the end of the |
244 | * echo skb FIFO plus one, i.e. the first free index. |
245 | * @tx_can_msg_cnt: Number of messages in @tx_urb. |
246 | * @tx_can_msg_is_fd: false: all messages in @tx_urb are Classical |
247 | * CAN, true: all messages in @tx_urb are CAN FD. Rationale: |
248 | * ES58X FD devices do not allow to mix Classical CAN and FD CAN |
249 | * frames in one single bulk transmission. |
250 | * @err_passive_before_rtx_success: The ES58X device might enter in a |
251 | * state in which it keeps alternating between error passive |
252 | * and active states. This counter keeps track of the number of |
253 | * error passive and if it gets bigger than |
254 | * ES58X_CONSECUTIVE_ERR_PASSIVE_MAX, es58x_rx_err_msg() will |
255 | * force the status to bus-off. |
256 | * @channel_idx: Channel index, starts at zero. |
257 | */ |
258 | struct es58x_priv { |
259 | struct can_priv can; |
260 | struct devlink_port devlink_port; |
261 | struct es58x_device *es58x_dev; |
262 | struct urb *tx_urb; |
263 | |
264 | u32 tx_tail; |
265 | u32 tx_head; |
266 | |
267 | u8 tx_can_msg_cnt; |
268 | bool tx_can_msg_is_fd; |
269 | |
270 | u8 err_passive_before_rtx_success; |
271 | |
272 | u8 channel_idx; |
273 | }; |
274 | |
275 | /** |
276 | * struct es58x_parameters - Constant parameters of a given hardware |
277 | * variant. |
278 | * @bittiming_const: Nominal bittimming constant parameters. |
279 | * @data_bittiming_const: Data bittiming constant parameters. |
280 | * @tdc_const: Transmission Delay Compensation constant parameters. |
281 | * @bitrate_max: Maximum bitrate supported by the device. |
282 | * @clock: CAN clock parameters. |
283 | * @ctrlmode_supported: List of supported modes. Please refer to |
284 | * can/netlink.h file for additional details. |
285 | * @tx_start_of_frame: Magic number at the beginning of each TX URB |
286 | * command. |
287 | * @rx_start_of_frame: Magic number at the beginning of each RX URB |
288 | * command. |
289 | * @tx_urb_cmd_max_len: Maximum length of a TX URB command. |
290 | * @rx_urb_cmd_max_len: Maximum length of a RX URB command. |
291 | * @fifo_mask: Bit mask to quickly convert the tx_tail and tx_head |
292 | * field of the struct es58x_priv into echo_skb |
293 | * indexes. Properties: @fifo_mask = echo_skb_max - 1 where |
294 | * echo_skb_max must be a power of two. Also, echo_skb_max must |
295 | * not exceed the maximum size of the device internal TX FIFO |
296 | * length. This parameter is used to control the network queue |
297 | * wake/stop logic. |
298 | * @dql_min_limit: Dynamic Queue Limits (DQL) absolute minimum limit |
299 | * of bytes allowed to be queued on this network device transmit |
300 | * queue. Used by the Byte Queue Limits (BQL) to determine how |
301 | * frequently the xmit_more flag will be set to true in |
302 | * es58x_start_xmit(). Set this value higher to optimize for |
303 | * throughput but be aware that it might have a negative impact |
304 | * on the latency! This value can also be set dynamically. Please |
305 | * refer to Documentation/ABI/testing/sysfs-class-net-queues for |
306 | * more details. |
307 | * @tx_bulk_max: Maximum number of TX messages that can be sent in one |
308 | * single URB packet. |
309 | * @urb_cmd_header_len: Length of the URB command header. |
310 | * @rx_urb_max: Number of RX URB to be allocated during device probe. |
311 | * @tx_urb_max: Number of TX URB to be allocated during device probe. |
312 | */ |
313 | struct es58x_parameters { |
314 | const struct can_bittiming_const *bittiming_const; |
315 | const struct can_bittiming_const *data_bittiming_const; |
316 | const struct can_tdc_const *tdc_const; |
317 | u32 bitrate_max; |
318 | struct can_clock clock; |
319 | u32 ctrlmode_supported; |
320 | u16 tx_start_of_frame; |
321 | u16 rx_start_of_frame; |
322 | u16 tx_urb_cmd_max_len; |
323 | u16 rx_urb_cmd_max_len; |
324 | u16 fifo_mask; |
325 | u16 dql_min_limit; |
326 | u8 tx_bulk_max; |
327 | u8 ; |
328 | u8 rx_urb_max; |
329 | u8 tx_urb_max; |
330 | }; |
331 | |
332 | /** |
333 | * struct es58x_operators - Function pointers used to encode/decode |
334 | * the TX/RX messages. |
335 | * @get_msg_len: Get field msg_len of the urb_cmd. The offset of |
336 | * msg_len inside urb_cmd depends of the device model. |
337 | * @handle_urb_cmd: Decode the URB command received from the device |
338 | * and dispatch it to the relevant sub function. |
339 | * @fill_urb_header: Fill the header of urb_cmd. |
340 | * @tx_can_msg: Encode a TX CAN message and add it to the bulk buffer |
341 | * cmd_buf of es58x_dev. |
342 | * @enable_channel: Start the CAN channel. |
343 | * @disable_channel: Stop the CAN channel. |
344 | * @reset_device: Full reset of the device. N.B: this feature is only |
345 | * present on the ES581.4. For ES58X FD devices, this field is |
346 | * set to NULL. |
347 | * @get_timestamp: Request a timestamp from the ES58X device. |
348 | */ |
349 | struct es58x_operators { |
350 | u16 (*get_msg_len)(const union es58x_urb_cmd *urb_cmd); |
351 | int (*handle_urb_cmd)(struct es58x_device *es58x_dev, |
352 | const union es58x_urb_cmd *urb_cmd); |
353 | void (*)(union es58x_urb_cmd *urb_cmd, u8 cmd_type, |
354 | u8 cmd_id, u8 channel_idx, u16 cmd_len); |
355 | int (*tx_can_msg)(struct es58x_priv *priv, const struct sk_buff *skb); |
356 | int (*enable_channel)(struct es58x_priv *priv); |
357 | int (*disable_channel)(struct es58x_priv *priv); |
358 | int (*reset_device)(struct es58x_device *es58x_dev); |
359 | int (*get_timestamp)(struct es58x_device *es58x_dev); |
360 | }; |
361 | |
362 | /** |
363 | * struct es58x_sw_version - Version number of the firmware or the |
364 | * bootloader. |
365 | * @major: Version major number, represented on two digits. |
366 | * @minor: Version minor number, represented on two digits. |
367 | * @revision: Version revision number, represented on two digits. |
368 | * |
369 | * The firmware and the bootloader share the same format: "xx.xx.xx" |
370 | * where 'x' is a digit. Both can be retrieved from the product |
371 | * information string. |
372 | */ |
373 | struct es58x_sw_version { |
374 | u8 major; |
375 | u8 minor; |
376 | u8 revision; |
377 | }; |
378 | |
379 | /** |
380 | * struct es58x_hw_revision - Hardware revision number. |
381 | * @letter: Revision letter, an alphanumeric character. |
382 | * @major: Version major number, represented on three digits. |
383 | * @minor: Version minor number, represented on three digits. |
384 | * |
385 | * The hardware revision uses its own format: "axxx/xxx" where 'a' is |
386 | * an alphanumeric character and 'x' a digit. It can be retrieved from |
387 | * the product information string. |
388 | */ |
389 | struct es58x_hw_revision { |
390 | char letter; |
391 | u16 major; |
392 | u16 minor; |
393 | }; |
394 | |
395 | /** |
396 | * struct es58x_device - All information specific to an ES58X device. |
397 | * @dev: Device information. |
398 | * @udev: USB device information. |
399 | * @netdev: Array of our CAN channels. |
400 | * @param: The constant parameters. |
401 | * @ops: Operators. |
402 | * @rx_pipe: USB reception pipe. |
403 | * @tx_pipe: USB transmission pipe. |
404 | * @rx_urbs: Anchor for received URBs. |
405 | * @tx_urbs_busy: Anchor for TX URBs which were send to the device. |
406 | * @tx_urbs_idle: Anchor for TX USB which are idle. This driver |
407 | * allocates the memory for the URBs during the probe. When a TX |
408 | * URB is needed, it can be taken from this anchor. The network |
409 | * queue wake/stop logic should prevent this URB from getting |
410 | * empty. Please refer to es58x_get_tx_urb() for more details. |
411 | * @tx_urbs_idle_cnt: number of urbs in @tx_urbs_idle. |
412 | * @firmware_version: The firmware version number. |
413 | * @bootloader_version: The bootloader version number. |
414 | * @hardware_revision: The hardware revision number. |
415 | * @ktime_req_ns: kernel timestamp when es58x_set_realtime_diff_ns() |
416 | * was called. |
417 | * @realtime_diff_ns: difference in nanoseconds between the clocks of |
418 | * the ES58X device and the kernel. |
419 | * @timestamps: a temporary buffer to store the time stamps before |
420 | * feeding them to es58x_can_get_echo_skb(). Can only be used |
421 | * in RX branches. |
422 | * @num_can_ch: Number of CAN channel (i.e. number of elements of @netdev). |
423 | * @opened_channel_cnt: number of channels opened. Free of race |
424 | * conditions because its two users (net_device_ops:ndo_open() |
425 | * and net_device_ops:ndo_close()) guarantee that the network |
426 | * stack big kernel lock (a.k.a. rtnl_mutex) is being hold. |
427 | * @rx_cmd_buf_len: Length of @rx_cmd_buf. |
428 | * @rx_cmd_buf: The device might split the URB commands in an |
429 | * arbitrary amount of pieces. This buffer is used to concatenate |
430 | * all those pieces. Can only be used in RX branches. This field |
431 | * has to be the last one of the structure because it is has a |
432 | * flexible size (c.f. es58x_sizeof_es58x_device() function). |
433 | */ |
434 | struct es58x_device { |
435 | struct device *dev; |
436 | struct usb_device *udev; |
437 | struct net_device *netdev[ES58X_NUM_CAN_CH_MAX]; |
438 | |
439 | const struct es58x_parameters *param; |
440 | const struct es58x_operators *ops; |
441 | |
442 | unsigned int rx_pipe; |
443 | unsigned int tx_pipe; |
444 | |
445 | struct usb_anchor rx_urbs; |
446 | struct usb_anchor tx_urbs_busy; |
447 | struct usb_anchor tx_urbs_idle; |
448 | atomic_t tx_urbs_idle_cnt; |
449 | |
450 | struct es58x_sw_version firmware_version; |
451 | struct es58x_sw_version bootloader_version; |
452 | struct es58x_hw_revision hardware_revision; |
453 | |
454 | u64 ktime_req_ns; |
455 | s64 realtime_diff_ns; |
456 | |
457 | u64 timestamps[ES58X_ECHO_BULK_MAX]; |
458 | |
459 | u8 num_can_ch; |
460 | u8 opened_channel_cnt; |
461 | |
462 | u16 rx_cmd_buf_len; |
463 | union es58x_urb_cmd rx_cmd_buf; |
464 | }; |
465 | |
466 | /** |
467 | * es58x_sizeof_es58x_device() - Calculate the maximum length of |
468 | * struct es58x_device. |
469 | * @es58x_dev_param: The constant parameters of the device. |
470 | * |
471 | * The length of struct es58x_device depends on the length of its last |
472 | * field: rx_cmd_buf. This macro allows to optimize the memory |
473 | * allocation. |
474 | * |
475 | * Return: length of struct es58x_device. |
476 | */ |
477 | static inline size_t es58x_sizeof_es58x_device(const struct es58x_parameters |
478 | *es58x_dev_param) |
479 | { |
480 | return offsetof(struct es58x_device, rx_cmd_buf) + |
481 | es58x_dev_param->rx_urb_cmd_max_len; |
482 | } |
483 | |
484 | static inline int __es58x_check_msg_len(const struct device *dev, |
485 | const char *stringified_msg, |
486 | size_t actual_len, size_t expected_len) |
487 | { |
488 | if (expected_len != actual_len) { |
489 | dev_err(dev, |
490 | "Length of %s is %zu but received command is %zu.\n" , |
491 | stringified_msg, expected_len, actual_len); |
492 | return -EMSGSIZE; |
493 | } |
494 | return 0; |
495 | } |
496 | |
497 | /** |
498 | * es58x_check_msg_len() - Check the size of a received message. |
499 | * @dev: Device, used to print error messages. |
500 | * @msg: Received message, must not be a pointer. |
501 | * @actual_len: Length of the message as advertised in the command header. |
502 | * |
503 | * Must be a macro in order to accept the different types of messages |
504 | * as an input. Can be use with any of the messages which have a fixed |
505 | * length. Check for an exact match of the size. |
506 | * |
507 | * Return: zero on success, -EMSGSIZE if @actual_len differs from the |
508 | * expected length. |
509 | */ |
510 | #define es58x_check_msg_len(dev, msg, actual_len) \ |
511 | __es58x_check_msg_len(dev, __stringify(msg), \ |
512 | actual_len, sizeof(msg)) |
513 | |
514 | static inline int __es58x_check_msg_max_len(const struct device *dev, |
515 | const char *stringified_msg, |
516 | size_t actual_len, |
517 | size_t expected_len) |
518 | { |
519 | if (actual_len > expected_len) { |
520 | dev_err(dev, |
521 | "Maximum length for %s is %zu but received command is %zu.\n" , |
522 | stringified_msg, expected_len, actual_len); |
523 | return -EOVERFLOW; |
524 | } |
525 | return 0; |
526 | } |
527 | |
528 | /** |
529 | * es58x_check_msg_max_len() - Check the maximum size of a received message. |
530 | * @dev: Device, used to print error messages. |
531 | * @msg: Received message, must not be a pointer. |
532 | * @actual_len: Length of the message as advertised in the command header. |
533 | * |
534 | * Must be a macro in order to accept the different types of messages |
535 | * as an input. To be used with the messages of variable sizes. Only |
536 | * check that the message is not bigger than the maximum expected |
537 | * size. |
538 | * |
539 | * Return: zero on success, -EOVERFLOW if @actual_len is greater than |
540 | * the expected length. |
541 | */ |
542 | #define es58x_check_msg_max_len(dev, msg, actual_len) \ |
543 | __es58x_check_msg_max_len(dev, __stringify(msg), \ |
544 | actual_len, sizeof(msg)) |
545 | |
546 | static inline int __es58x_msg_num_element(const struct device *dev, |
547 | const char *stringified_msg, |
548 | size_t actual_len, size_t msg_len, |
549 | size_t elem_len) |
550 | { |
551 | size_t actual_num_elem = actual_len / elem_len; |
552 | size_t expected_num_elem = msg_len / elem_len; |
553 | |
554 | if (actual_num_elem == 0) { |
555 | dev_err(dev, |
556 | "Minimum length for %s is %zu but received command is %zu.\n" , |
557 | stringified_msg, elem_len, actual_len); |
558 | return -EMSGSIZE; |
559 | } else if ((actual_len % elem_len) != 0) { |
560 | dev_err(dev, |
561 | "Received command length: %zu is not a multiple of %s[0]: %zu\n" , |
562 | actual_len, stringified_msg, elem_len); |
563 | return -EMSGSIZE; |
564 | } else if (actual_num_elem > expected_num_elem) { |
565 | dev_err(dev, |
566 | "Array %s is supposed to have %zu elements each of size %zu...\n" , |
567 | stringified_msg, expected_num_elem, elem_len); |
568 | dev_err(dev, |
569 | "... But received command has %zu elements (total length %zu).\n" , |
570 | actual_num_elem, actual_len); |
571 | return -EOVERFLOW; |
572 | } |
573 | return actual_num_elem; |
574 | } |
575 | |
576 | /** |
577 | * es58x_msg_num_element() - Check size and give the number of |
578 | * elements in a message of array type. |
579 | * @dev: Device, used to print error messages. |
580 | * @msg: Received message, must be an array. |
581 | * @actual_len: Length of the message as advertised in the command |
582 | * header. |
583 | * |
584 | * Must be a macro in order to accept the different types of messages |
585 | * as an input. To be used on message of array type. Array's element |
586 | * has to be of fixed size (else use es58x_check_msg_max_len()). Check |
587 | * that the total length is an exact multiple of the length of a |
588 | * single element. |
589 | * |
590 | * Return: number of elements in the array on success, -EOVERFLOW if |
591 | * @actual_len is greater than the expected length, -EMSGSIZE if |
592 | * @actual_len is not a multiple of a single element. |
593 | */ |
594 | #define es58x_msg_num_element(dev, msg, actual_len) \ |
595 | ({ \ |
596 | size_t __elem_len = sizeof((msg)[0]) + __must_be_array(msg); \ |
597 | __es58x_msg_num_element(dev, __stringify(msg), actual_len, \ |
598 | sizeof(msg), __elem_len); \ |
599 | }) |
600 | |
601 | /** |
602 | * es58x_priv() - Get the priv member and cast it to struct es58x_priv. |
603 | * @netdev: CAN network device. |
604 | * |
605 | * Return: ES58X device. |
606 | */ |
607 | static inline struct es58x_priv *es58x_priv(struct net_device *netdev) |
608 | { |
609 | return (struct es58x_priv *)netdev_priv(dev: netdev); |
610 | } |
611 | |
612 | /** |
613 | * ES58X_SIZEOF_URB_CMD() - Calculate the maximum length of an urb |
614 | * command for a given message field name. |
615 | * @es58x_urb_cmd_type: type (either "struct es581_4_urb_cmd" or |
616 | * "struct es58x_fd_urb_cmd"). |
617 | * @msg_field: name of the message field. |
618 | * |
619 | * Must be a macro in order to accept the different command types as |
620 | * an input. |
621 | * |
622 | * Return: length of the urb command. |
623 | */ |
624 | #define ES58X_SIZEOF_URB_CMD(es58x_urb_cmd_type, msg_field) \ |
625 | (offsetof(es58x_urb_cmd_type, raw_msg) \ |
626 | + sizeof_field(es58x_urb_cmd_type, msg_field) \ |
627 | + sizeof_field(es58x_urb_cmd_type, \ |
628 | reserved_for_crc16_do_not_use)) |
629 | |
630 | /** |
631 | * es58x_get_urb_cmd_len() - Calculate the actual length of an urb |
632 | * command for a given message length. |
633 | * @es58x_dev: ES58X device. |
634 | * @msg_len: Length of the message. |
635 | * |
636 | * Add the header and CRC lengths to the message length. |
637 | * |
638 | * Return: length of the urb command. |
639 | */ |
640 | static inline size_t es58x_get_urb_cmd_len(struct es58x_device *es58x_dev, |
641 | u16 msg_len) |
642 | { |
643 | return es58x_dev->param->urb_cmd_header_len + msg_len + sizeof(u16); |
644 | } |
645 | |
646 | /** |
647 | * es58x_get_netdev() - Get the network device. |
648 | * @es58x_dev: ES58X device. |
649 | * @channel_no: The channel number as advertised in the urb command. |
650 | * @channel_idx_offset: Some of the ES58x starts channel numbering |
651 | * from 0 (ES58X FD), others from 1 (ES581.4). |
652 | * @netdev: CAN network device. |
653 | * |
654 | * Do a sanity check on the index provided by the device. |
655 | * |
656 | * Return: zero on success, -ECHRNG if the received channel number is |
657 | * out of range and -ENODEV if the network device is not yet |
658 | * configured. |
659 | */ |
660 | static inline int es58x_get_netdev(struct es58x_device *es58x_dev, |
661 | int channel_no, int channel_idx_offset, |
662 | struct net_device **netdev) |
663 | { |
664 | int channel_idx = channel_no - channel_idx_offset; |
665 | |
666 | *netdev = NULL; |
667 | if (channel_idx < 0 || channel_idx >= es58x_dev->num_can_ch) |
668 | return -ECHRNG; |
669 | |
670 | *netdev = es58x_dev->netdev[channel_idx]; |
671 | if (!*netdev || !netif_device_present(dev: *netdev)) |
672 | return -ENODEV; |
673 | |
674 | return 0; |
675 | } |
676 | |
677 | /** |
678 | * es58x_get_raw_can_id() - Get the CAN ID. |
679 | * @cf: CAN frame. |
680 | * |
681 | * Mask the CAN ID in order to only keep the significant bits. |
682 | * |
683 | * Return: the raw value of the CAN ID. |
684 | */ |
685 | static inline int es58x_get_raw_can_id(const struct can_frame *cf) |
686 | { |
687 | if (cf->can_id & CAN_EFF_FLAG) |
688 | return cf->can_id & CAN_EFF_MASK; |
689 | else |
690 | return cf->can_id & CAN_SFF_MASK; |
691 | } |
692 | |
693 | /** |
694 | * es58x_get_flags() - Get the CAN flags. |
695 | * @skb: socket buffer of a CAN message. |
696 | * |
697 | * Return: the CAN flag as an enum es58x_flag. |
698 | */ |
699 | static inline enum es58x_flag es58x_get_flags(const struct sk_buff *skb) |
700 | { |
701 | struct canfd_frame *cf = (struct canfd_frame *)skb->data; |
702 | enum es58x_flag es58x_flags = 0; |
703 | |
704 | if (cf->can_id & CAN_EFF_FLAG) |
705 | es58x_flags |= ES58X_FLAG_EFF; |
706 | |
707 | if (can_is_canfd_skb(skb)) { |
708 | es58x_flags |= ES58X_FLAG_FD_DATA; |
709 | if (cf->flags & CANFD_BRS) |
710 | es58x_flags |= ES58X_FLAG_FD_BRS; |
711 | if (cf->flags & CANFD_ESI) |
712 | es58x_flags |= ES58X_FLAG_FD_ESI; |
713 | } else if (cf->can_id & CAN_RTR_FLAG) |
714 | /* Remote frames are only defined in Classical CAN frames */ |
715 | es58x_flags |= ES58X_FLAG_RTR; |
716 | |
717 | return es58x_flags; |
718 | } |
719 | |
720 | /* es58x_core.c. */ |
721 | int es58x_can_get_echo_skb(struct net_device *netdev, u32 packet_idx, |
722 | u64 *tstamps, unsigned int pkts); |
723 | int es58x_tx_ack_msg(struct net_device *netdev, u16 tx_free_entries, |
724 | enum es58x_ret_u32 rx_cmd_ret_u32); |
725 | int es58x_rx_can_msg(struct net_device *netdev, u64 timestamp, const u8 *data, |
726 | canid_t can_id, enum es58x_flag es58x_flags, u8 dlc); |
727 | int es58x_rx_err_msg(struct net_device *netdev, enum es58x_err error, |
728 | enum es58x_event event, u64 timestamp); |
729 | void es58x_rx_timestamp(struct es58x_device *es58x_dev, u64 timestamp); |
730 | int es58x_rx_cmd_ret_u8(struct device *dev, enum es58x_ret_type cmd_ret_type, |
731 | enum es58x_ret_u8 rx_cmd_ret_u8); |
732 | int es58x_rx_cmd_ret_u32(struct net_device *netdev, |
733 | enum es58x_ret_type cmd_ret_type, |
734 | enum es58x_ret_u32 rx_cmd_ret_u32); |
735 | int es58x_send_msg(struct es58x_device *es58x_dev, u8 cmd_type, u8 cmd_id, |
736 | const void *msg, u16 cmd_len, int channel_idx); |
737 | |
738 | /* es58x_devlink.c. */ |
739 | void es58x_parse_product_info(struct es58x_device *es58x_dev); |
740 | extern const struct devlink_ops es58x_dl_ops; |
741 | |
742 | /* es581_4.c. */ |
743 | extern const struct es58x_parameters es581_4_param; |
744 | extern const struct es58x_operators es581_4_ops; |
745 | |
746 | /* es58x_fd.c. */ |
747 | extern const struct es58x_parameters es58x_fd_param; |
748 | extern const struct es58x_operators es58x_fd_ops; |
749 | |
750 | #endif /* __ES58X_COMMON_H__ */ |
751 | |