1 | // SPDX-License-Identifier: GPL-2.0 |
2 | |
3 | /* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces. |
4 | * |
5 | * File es58x_fd.c: Adds support to ETAS ES582.1 and ES584.1 (naming |
6 | * convention: we use the term "ES58X FD" when referring to those two |
7 | * variants together). |
8 | * |
9 | * Copyright (c) 2019 Robert Bosch Engineering and Business Solutions. All rights reserved. |
10 | * Copyright (c) 2020 ETAS K.K.. All rights reserved. |
11 | * Copyright (c) 2020-2022 Vincent Mailhol <mailhol.vincent@wanadoo.fr> |
12 | */ |
13 | |
14 | #include <asm/unaligned.h> |
15 | #include <linux/kernel.h> |
16 | #include <linux/units.h> |
17 | |
18 | #include "es58x_core.h" |
19 | #include "es58x_fd.h" |
20 | |
21 | /** |
22 | * es58x_fd_sizeof_rx_tx_msg() - Calculate the actual length of the |
23 | * structure of a rx or tx message. |
24 | * @msg: message of variable length, must have a dlc and a len fields. |
25 | * |
26 | * Even if RTR frames have actually no payload, the ES58X devices |
27 | * still expect it. Must be a macro in order to accept several types |
28 | * (struct es58x_fd_tx_can_msg and struct es58x_fd_rx_can_msg) as an |
29 | * input. |
30 | * |
31 | * Return: length of the message. |
32 | */ |
33 | #define es58x_fd_sizeof_rx_tx_msg(msg) \ |
34 | ({ \ |
35 | typeof(msg) __msg = (msg); \ |
36 | size_t __msg_len; \ |
37 | \ |
38 | if (__msg.flags & ES58X_FLAG_FD_DATA) \ |
39 | __msg_len = canfd_sanitize_len(__msg.len); \ |
40 | else \ |
41 | __msg_len = can_cc_dlc2len(__msg.dlc); \ |
42 | \ |
43 | offsetof(typeof(__msg), data[__msg_len]); \ |
44 | }) |
45 | |
46 | static enum es58x_fd_cmd_type es58x_fd_cmd_type(struct net_device *netdev) |
47 | { |
48 | u32 ctrlmode = es58x_priv(netdev)->can.ctrlmode; |
49 | |
50 | if (ctrlmode & (CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO)) |
51 | return ES58X_FD_CMD_TYPE_CANFD; |
52 | else |
53 | return ES58X_FD_CMD_TYPE_CAN; |
54 | } |
55 | |
56 | static u16 es58x_fd_get_msg_len(const union es58x_urb_cmd *urb_cmd) |
57 | { |
58 | return get_unaligned_le16(p: &urb_cmd->es58x_fd_urb_cmd.msg_len); |
59 | } |
60 | |
61 | static int es58x_fd_echo_msg(struct net_device *netdev, |
62 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) |
63 | { |
64 | struct es58x_priv *priv = es58x_priv(netdev); |
65 | const struct es58x_fd_echo_msg *echo_msg; |
66 | struct es58x_device *es58x_dev = priv->es58x_dev; |
67 | u64 *tstamps = es58x_dev->timestamps; |
68 | u16 msg_len = get_unaligned_le16(p: &es58x_fd_urb_cmd->msg_len); |
69 | int i, num_element; |
70 | u32 rcv_packet_idx; |
71 | |
72 | const u32 mask = GENMASK(BITS_PER_TYPE(mask) - 1, |
73 | BITS_PER_TYPE(echo_msg->packet_idx)); |
74 | |
75 | num_element = es58x_msg_num_element(es58x_dev->dev, |
76 | es58x_fd_urb_cmd->echo_msg, |
77 | msg_len); |
78 | if (num_element < 0) |
79 | return num_element; |
80 | echo_msg = es58x_fd_urb_cmd->echo_msg; |
81 | |
82 | rcv_packet_idx = (priv->tx_tail & mask) | echo_msg[0].packet_idx; |
83 | for (i = 0; i < num_element; i++) { |
84 | if ((u8)rcv_packet_idx != echo_msg[i].packet_idx) { |
85 | netdev_err(dev: netdev, format: "Packet idx jumped from %u to %u\n" , |
86 | (u8)rcv_packet_idx - 1, |
87 | echo_msg[i].packet_idx); |
88 | return -EBADMSG; |
89 | } |
90 | |
91 | tstamps[i] = get_unaligned_le64(p: &echo_msg[i].timestamp); |
92 | rcv_packet_idx++; |
93 | } |
94 | |
95 | return es58x_can_get_echo_skb(netdev, packet_idx: priv->tx_tail, tstamps, pkts: num_element); |
96 | } |
97 | |
98 | static int es58x_fd_rx_can_msg(struct net_device *netdev, |
99 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) |
100 | { |
101 | struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev; |
102 | const u8 *rx_can_msg_buf = es58x_fd_urb_cmd->rx_can_msg_buf; |
103 | u16 rx_can_msg_buf_len = get_unaligned_le16(p: &es58x_fd_urb_cmd->msg_len); |
104 | int pkts, ret; |
105 | |
106 | ret = es58x_check_msg_max_len(es58x_dev->dev, |
107 | es58x_fd_urb_cmd->rx_can_msg_buf, |
108 | rx_can_msg_buf_len); |
109 | if (ret) |
110 | return ret; |
111 | |
112 | for (pkts = 0; rx_can_msg_buf_len > 0; pkts++) { |
113 | const struct es58x_fd_rx_can_msg *rx_can_msg = |
114 | (const struct es58x_fd_rx_can_msg *)rx_can_msg_buf; |
115 | bool is_can_fd = !!(rx_can_msg->flags & ES58X_FLAG_FD_DATA); |
116 | /* rx_can_msg_len is the length of the rx_can_msg |
117 | * buffer. Not to be confused with rx_can_msg->len |
118 | * which is the length of the CAN payload |
119 | * rx_can_msg->data. |
120 | */ |
121 | u16 rx_can_msg_len = es58x_fd_sizeof_rx_tx_msg(*rx_can_msg); |
122 | |
123 | if (rx_can_msg_len > rx_can_msg_buf_len) { |
124 | netdev_err(dev: netdev, |
125 | format: "%s: Expected a rx_can_msg of size %d but only %d bytes are left in rx_can_msg_buf\n" , |
126 | __func__, |
127 | rx_can_msg_len, rx_can_msg_buf_len); |
128 | return -EMSGSIZE; |
129 | } |
130 | if (rx_can_msg->len > CANFD_MAX_DLEN) { |
131 | netdev_err(dev: netdev, |
132 | format: "%s: Data length is %d but maximum should be %d\n" , |
133 | __func__, rx_can_msg->len, CANFD_MAX_DLEN); |
134 | return -EMSGSIZE; |
135 | } |
136 | |
137 | if (netif_running(dev: netdev)) { |
138 | u64 tstamp = get_unaligned_le64(p: &rx_can_msg->timestamp); |
139 | canid_t can_id = get_unaligned_le32(p: &rx_can_msg->can_id); |
140 | u8 dlc; |
141 | |
142 | if (is_can_fd) |
143 | dlc = can_fd_len2dlc(len: rx_can_msg->len); |
144 | else |
145 | dlc = rx_can_msg->dlc; |
146 | |
147 | ret = es58x_rx_can_msg(netdev, timestamp: tstamp, data: rx_can_msg->data, |
148 | can_id, es58x_flags: rx_can_msg->flags, dlc); |
149 | if (ret) |
150 | break; |
151 | } |
152 | |
153 | rx_can_msg_buf_len -= rx_can_msg_len; |
154 | rx_can_msg_buf += rx_can_msg_len; |
155 | } |
156 | |
157 | if (!netif_running(dev: netdev)) { |
158 | if (net_ratelimit()) |
159 | netdev_info(dev: netdev, |
160 | format: "%s: %s is down, dropping %d rx packets\n" , |
161 | __func__, netdev->name, pkts); |
162 | netdev->stats.rx_dropped += pkts; |
163 | } |
164 | |
165 | return ret; |
166 | } |
167 | |
168 | static int es58x_fd_rx_event_msg(struct net_device *netdev, |
169 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) |
170 | { |
171 | struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev; |
172 | u16 msg_len = get_unaligned_le16(p: &es58x_fd_urb_cmd->msg_len); |
173 | const struct es58x_fd_rx_event_msg *rx_event_msg; |
174 | int ret; |
175 | |
176 | rx_event_msg = &es58x_fd_urb_cmd->rx_event_msg; |
177 | ret = es58x_check_msg_len(es58x_dev->dev, *rx_event_msg, msg_len); |
178 | if (ret) |
179 | return ret; |
180 | |
181 | return es58x_rx_err_msg(netdev, error: rx_event_msg->error_code, |
182 | event: rx_event_msg->event_code, |
183 | timestamp: get_unaligned_le64(p: &rx_event_msg->timestamp)); |
184 | } |
185 | |
186 | static int es58x_fd_rx_cmd_ret_u32(struct net_device *netdev, |
187 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd, |
188 | enum es58x_ret_type cmd_ret_type) |
189 | { |
190 | struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev; |
191 | u16 msg_len = get_unaligned_le16(p: &es58x_fd_urb_cmd->msg_len); |
192 | int ret; |
193 | |
194 | ret = es58x_check_msg_len(es58x_dev->dev, |
195 | es58x_fd_urb_cmd->rx_cmd_ret_le32, msg_len); |
196 | if (ret) |
197 | return ret; |
198 | |
199 | return es58x_rx_cmd_ret_u32(netdev, cmd_ret_type, |
200 | rx_cmd_ret_u32: get_unaligned_le32(p: &es58x_fd_urb_cmd->rx_cmd_ret_le32)); |
201 | } |
202 | |
203 | static int es58x_fd_tx_ack_msg(struct net_device *netdev, |
204 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) |
205 | { |
206 | struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev; |
207 | const struct es58x_fd_tx_ack_msg *tx_ack_msg; |
208 | u16 msg_len = get_unaligned_le16(p: &es58x_fd_urb_cmd->msg_len); |
209 | int ret; |
210 | |
211 | tx_ack_msg = &es58x_fd_urb_cmd->tx_ack_msg; |
212 | ret = es58x_check_msg_len(es58x_dev->dev, *tx_ack_msg, msg_len); |
213 | if (ret) |
214 | return ret; |
215 | |
216 | return es58x_tx_ack_msg(netdev, |
217 | tx_free_entries: get_unaligned_le16(p: &tx_ack_msg->tx_free_entries), |
218 | rx_cmd_ret_u32: get_unaligned_le32(p: &tx_ack_msg->rx_cmd_ret_le32)); |
219 | } |
220 | |
221 | static int es58x_fd_can_cmd_id(struct es58x_device *es58x_dev, |
222 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) |
223 | { |
224 | struct net_device *netdev; |
225 | int ret; |
226 | |
227 | ret = es58x_get_netdev(es58x_dev, channel_no: es58x_fd_urb_cmd->channel_idx, |
228 | ES58X_FD_CHANNEL_IDX_OFFSET, netdev: &netdev); |
229 | if (ret) |
230 | return ret; |
231 | |
232 | switch ((enum es58x_fd_can_cmd_id)es58x_fd_urb_cmd->cmd_id) { |
233 | case ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL: |
234 | return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, |
235 | cmd_ret_type: ES58X_RET_TYPE_ENABLE_CHANNEL); |
236 | |
237 | case ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL: |
238 | return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, |
239 | cmd_ret_type: ES58X_RET_TYPE_DISABLE_CHANNEL); |
240 | |
241 | case ES58X_FD_CAN_CMD_ID_TX_MSG: |
242 | return es58x_fd_tx_ack_msg(netdev, es58x_fd_urb_cmd); |
243 | |
244 | case ES58X_FD_CAN_CMD_ID_ECHO_MSG: |
245 | return es58x_fd_echo_msg(netdev, es58x_fd_urb_cmd); |
246 | |
247 | case ES58X_FD_CAN_CMD_ID_RX_MSG: |
248 | return es58x_fd_rx_can_msg(netdev, es58x_fd_urb_cmd); |
249 | |
250 | case ES58X_FD_CAN_CMD_ID_RESET_RX: |
251 | return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, |
252 | cmd_ret_type: ES58X_RET_TYPE_RESET_RX); |
253 | |
254 | case ES58X_FD_CAN_CMD_ID_RESET_TX: |
255 | return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, |
256 | cmd_ret_type: ES58X_RET_TYPE_RESET_TX); |
257 | |
258 | case ES58X_FD_CAN_CMD_ID_ERROR_OR_EVENT_MSG: |
259 | return es58x_fd_rx_event_msg(netdev, es58x_fd_urb_cmd); |
260 | |
261 | default: |
262 | return -EBADRQC; |
263 | } |
264 | } |
265 | |
266 | static int es58x_fd_device_cmd_id(struct es58x_device *es58x_dev, |
267 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) |
268 | { |
269 | u16 msg_len = get_unaligned_le16(p: &es58x_fd_urb_cmd->msg_len); |
270 | int ret; |
271 | |
272 | switch ((enum es58x_fd_dev_cmd_id)es58x_fd_urb_cmd->cmd_id) { |
273 | case ES58X_FD_DEV_CMD_ID_TIMESTAMP: |
274 | ret = es58x_check_msg_len(es58x_dev->dev, |
275 | es58x_fd_urb_cmd->timestamp, msg_len); |
276 | if (ret) |
277 | return ret; |
278 | es58x_rx_timestamp(es58x_dev, |
279 | timestamp: get_unaligned_le64(p: &es58x_fd_urb_cmd->timestamp)); |
280 | return 0; |
281 | |
282 | default: |
283 | return -EBADRQC; |
284 | } |
285 | } |
286 | |
287 | static int es58x_fd_handle_urb_cmd(struct es58x_device *es58x_dev, |
288 | const union es58x_urb_cmd *urb_cmd) |
289 | { |
290 | const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd; |
291 | int ret; |
292 | |
293 | es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd; |
294 | |
295 | switch ((enum es58x_fd_cmd_type)es58x_fd_urb_cmd->cmd_type) { |
296 | case ES58X_FD_CMD_TYPE_CAN: |
297 | case ES58X_FD_CMD_TYPE_CANFD: |
298 | ret = es58x_fd_can_cmd_id(es58x_dev, es58x_fd_urb_cmd); |
299 | break; |
300 | |
301 | case ES58X_FD_CMD_TYPE_DEVICE: |
302 | ret = es58x_fd_device_cmd_id(es58x_dev, es58x_fd_urb_cmd); |
303 | break; |
304 | |
305 | default: |
306 | ret = -EBADRQC; |
307 | break; |
308 | } |
309 | |
310 | if (ret == -EBADRQC) |
311 | dev_err(es58x_dev->dev, |
312 | "%s: Unknown command type (0x%02X) and command ID (0x%02X) combination\n" , |
313 | __func__, es58x_fd_urb_cmd->cmd_type, |
314 | es58x_fd_urb_cmd->cmd_id); |
315 | |
316 | return ret; |
317 | } |
318 | |
319 | static void (union es58x_urb_cmd *urb_cmd, u8 cmd_type, |
320 | u8 cmd_id, u8 channel_idx, u16 msg_len) |
321 | { |
322 | struct es58x_fd_urb_cmd *es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd; |
323 | |
324 | es58x_fd_urb_cmd->SOF = cpu_to_le16(es58x_fd_param.tx_start_of_frame); |
325 | es58x_fd_urb_cmd->cmd_type = cmd_type; |
326 | es58x_fd_urb_cmd->cmd_id = cmd_id; |
327 | es58x_fd_urb_cmd->channel_idx = channel_idx; |
328 | es58x_fd_urb_cmd->msg_len = cpu_to_le16(msg_len); |
329 | } |
330 | |
331 | static int es58x_fd_tx_can_msg(struct es58x_priv *priv, |
332 | const struct sk_buff *skb) |
333 | { |
334 | struct es58x_device *es58x_dev = priv->es58x_dev; |
335 | union es58x_urb_cmd *urb_cmd = priv->tx_urb->transfer_buffer; |
336 | struct es58x_fd_urb_cmd *es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd; |
337 | struct can_frame *cf = (struct can_frame *)skb->data; |
338 | struct es58x_fd_tx_can_msg *tx_can_msg; |
339 | bool is_fd = can_is_canfd_skb(skb); |
340 | u16 msg_len; |
341 | int ret; |
342 | |
343 | if (priv->tx_can_msg_cnt == 0) { |
344 | msg_len = 0; |
345 | es58x_fd_fill_urb_header(urb_cmd, |
346 | cmd_type: is_fd ? ES58X_FD_CMD_TYPE_CANFD |
347 | : ES58X_FD_CMD_TYPE_CAN, |
348 | cmd_id: ES58X_FD_CAN_CMD_ID_TX_MSG_NO_ACK, |
349 | channel_idx: priv->channel_idx, msg_len); |
350 | } else { |
351 | msg_len = es58x_fd_get_msg_len(urb_cmd); |
352 | } |
353 | |
354 | ret = es58x_check_msg_max_len(es58x_dev->dev, |
355 | es58x_fd_urb_cmd->tx_can_msg_buf, |
356 | msg_len + sizeof(*tx_can_msg)); |
357 | if (ret) |
358 | return ret; |
359 | |
360 | /* Fill message contents. */ |
361 | tx_can_msg = (typeof(tx_can_msg))&es58x_fd_urb_cmd->raw_msg[msg_len]; |
362 | tx_can_msg->packet_idx = (u8)priv->tx_head; |
363 | put_unaligned_le32(val: es58x_get_raw_can_id(cf), p: &tx_can_msg->can_id); |
364 | tx_can_msg->flags = (u8)es58x_get_flags(skb); |
365 | if (is_fd) |
366 | tx_can_msg->len = cf->len; |
367 | else |
368 | tx_can_msg->dlc = can_get_cc_dlc(cf, ctrlmode: priv->can.ctrlmode); |
369 | memcpy(tx_can_msg->data, cf->data, cf->len); |
370 | |
371 | /* Calculate new sizes */ |
372 | msg_len += es58x_fd_sizeof_rx_tx_msg(*tx_can_msg); |
373 | priv->tx_urb->transfer_buffer_length = es58x_get_urb_cmd_len(es58x_dev, |
374 | msg_len); |
375 | put_unaligned_le16(val: msg_len, p: &es58x_fd_urb_cmd->msg_len); |
376 | |
377 | return 0; |
378 | } |
379 | |
380 | static void es58x_fd_convert_bittiming(struct es58x_fd_bittiming *es58x_fd_bt, |
381 | struct can_bittiming *bt) |
382 | { |
383 | /* The actual value set in the hardware registers is one less |
384 | * than the functional value. |
385 | */ |
386 | const int offset = 1; |
387 | |
388 | es58x_fd_bt->bitrate = cpu_to_le32(bt->bitrate); |
389 | es58x_fd_bt->tseg1 = |
390 | cpu_to_le16(bt->prop_seg + bt->phase_seg1 - offset); |
391 | es58x_fd_bt->tseg2 = cpu_to_le16(bt->phase_seg2 - offset); |
392 | es58x_fd_bt->brp = cpu_to_le16(bt->brp - offset); |
393 | es58x_fd_bt->sjw = cpu_to_le16(bt->sjw - offset); |
394 | } |
395 | |
396 | static int es58x_fd_enable_channel(struct es58x_priv *priv) |
397 | { |
398 | struct es58x_device *es58x_dev = priv->es58x_dev; |
399 | struct net_device *netdev = es58x_dev->netdev[priv->channel_idx]; |
400 | struct es58x_fd_tx_conf_msg tx_conf_msg = { 0 }; |
401 | u32 ctrlmode; |
402 | size_t conf_len = 0; |
403 | |
404 | es58x_fd_convert_bittiming(es58x_fd_bt: &tx_conf_msg.nominal_bittiming, |
405 | bt: &priv->can.bittiming); |
406 | ctrlmode = priv->can.ctrlmode; |
407 | |
408 | if (ctrlmode & CAN_CTRLMODE_3_SAMPLES) |
409 | tx_conf_msg.samples_per_bit = ES58X_SAMPLES_PER_BIT_THREE; |
410 | else |
411 | tx_conf_msg.samples_per_bit = ES58X_SAMPLES_PER_BIT_ONE; |
412 | tx_conf_msg.sync_edge = ES58X_SYNC_EDGE_SINGLE; |
413 | tx_conf_msg.physical_layer = ES58X_PHYSICAL_LAYER_HIGH_SPEED; |
414 | tx_conf_msg.echo_mode = ES58X_ECHO_ON; |
415 | if (ctrlmode & CAN_CTRLMODE_LISTENONLY) |
416 | tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_PASSIVE; |
417 | else |
418 | tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_ACTIVE; |
419 | |
420 | if (ctrlmode & CAN_CTRLMODE_FD_NON_ISO) { |
421 | tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_FD_NON_ISO; |
422 | tx_conf_msg.canfd_enabled = 1; |
423 | } else if (ctrlmode & CAN_CTRLMODE_FD) { |
424 | tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_FD; |
425 | tx_conf_msg.canfd_enabled = 1; |
426 | } |
427 | |
428 | if (tx_conf_msg.canfd_enabled) { |
429 | es58x_fd_convert_bittiming(es58x_fd_bt: &tx_conf_msg.data_bittiming, |
430 | bt: &priv->can.data_bittiming); |
431 | |
432 | if (can_tdc_is_enabled(priv: &priv->can)) { |
433 | tx_conf_msg.tdc_enabled = 1; |
434 | tx_conf_msg.tdco = cpu_to_le16(priv->can.tdc.tdco); |
435 | tx_conf_msg.tdcf = cpu_to_le16(priv->can.tdc.tdcf); |
436 | } |
437 | |
438 | conf_len = ES58X_FD_CANFD_CONF_LEN; |
439 | } else { |
440 | conf_len = ES58X_FD_CAN_CONF_LEN; |
441 | } |
442 | |
443 | return es58x_send_msg(es58x_dev, cmd_type: es58x_fd_cmd_type(netdev), |
444 | cmd_id: ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL, |
445 | msg: &tx_conf_msg, cmd_len: conf_len, channel_idx: priv->channel_idx); |
446 | } |
447 | |
448 | static int es58x_fd_disable_channel(struct es58x_priv *priv) |
449 | { |
450 | /* The type (ES58X_FD_CMD_TYPE_CAN or ES58X_FD_CMD_TYPE_CANFD) does |
451 | * not matter here. |
452 | */ |
453 | return es58x_send_msg(es58x_dev: priv->es58x_dev, cmd_type: ES58X_FD_CMD_TYPE_CAN, |
454 | cmd_id: ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL, |
455 | ES58X_EMPTY_MSG, cmd_len: 0, channel_idx: priv->channel_idx); |
456 | } |
457 | |
458 | static int es58x_fd_get_timestamp(struct es58x_device *es58x_dev) |
459 | { |
460 | return es58x_send_msg(es58x_dev, cmd_type: ES58X_FD_CMD_TYPE_DEVICE, |
461 | cmd_id: ES58X_FD_DEV_CMD_ID_TIMESTAMP, ES58X_EMPTY_MSG, |
462 | cmd_len: 0, ES58X_CHANNEL_IDX_NA); |
463 | } |
464 | |
465 | /* Nominal bittiming constants for ES582.1 and ES584.1 as specified in |
466 | * the microcontroller datasheet: "SAM E70/S70/V70/V71 Family" section |
467 | * 49.6.8 "MCAN Nominal Bit Timing and Prescaler Register" from |
468 | * Microchip. |
469 | * |
470 | * The values from the specification are the hardware register |
471 | * values. To convert them to the functional values, all ranges were |
472 | * incremented by 1 (e.g. range [0..n-1] changed to [1..n]). |
473 | */ |
474 | static const struct can_bittiming_const es58x_fd_nom_bittiming_const = { |
475 | .name = "ES582.1/ES584.1" , |
476 | .tseg1_min = 2, |
477 | .tseg1_max = 256, |
478 | .tseg2_min = 2, |
479 | .tseg2_max = 128, |
480 | .sjw_max = 128, |
481 | .brp_min = 1, |
482 | .brp_max = 512, |
483 | .brp_inc = 1 |
484 | }; |
485 | |
486 | /* Data bittiming constants for ES582.1 and ES584.1 as specified in |
487 | * the microcontroller datasheet: "SAM E70/S70/V70/V71 Family" section |
488 | * 49.6.4 "MCAN Data Bit Timing and Prescaler Register" from |
489 | * Microchip. |
490 | */ |
491 | static const struct can_bittiming_const es58x_fd_data_bittiming_const = { |
492 | .name = "ES582.1/ES584.1" , |
493 | .tseg1_min = 2, |
494 | .tseg1_max = 32, |
495 | .tseg2_min = 1, |
496 | .tseg2_max = 16, |
497 | .sjw_max = 8, |
498 | .brp_min = 1, |
499 | .brp_max = 32, |
500 | .brp_inc = 1 |
501 | }; |
502 | |
503 | /* Transmission Delay Compensation constants for ES582.1 and ES584.1 |
504 | * as specified in the microcontroller datasheet: "SAM E70/S70/V70/V71 |
505 | * Family" section 49.6.15 "MCAN Transmitter Delay Compensation |
506 | * Register" from Microchip. |
507 | */ |
508 | static const struct can_tdc_const es58x_tdc_const = { |
509 | .tdcv_min = 0, |
510 | .tdcv_max = 0, /* Manual mode not supported. */ |
511 | .tdco_min = 0, |
512 | .tdco_max = 127, |
513 | .tdcf_min = 0, |
514 | .tdcf_max = 127 |
515 | }; |
516 | |
517 | const struct es58x_parameters es58x_fd_param = { |
518 | .bittiming_const = &es58x_fd_nom_bittiming_const, |
519 | .data_bittiming_const = &es58x_fd_data_bittiming_const, |
520 | .tdc_const = &es58x_tdc_const, |
521 | /* The devices use NXP TJA1044G transievers which guarantee |
522 | * the timing for data rates up to 5 Mbps. Bitrates up to 8 |
523 | * Mbps work in an optimal environment but are not recommended |
524 | * for production environment. |
525 | */ |
526 | .bitrate_max = 8 * MEGA /* BPS */, |
527 | .clock = {.freq = 80 * MEGA /* Hz */}, |
528 | .ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY | |
529 | CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO | |
530 | CAN_CTRLMODE_CC_LEN8_DLC | CAN_CTRLMODE_TDC_AUTO, |
531 | .tx_start_of_frame = 0xCEFA, /* FACE in little endian */ |
532 | .rx_start_of_frame = 0xFECA, /* CAFE in little endian */ |
533 | .tx_urb_cmd_max_len = ES58X_FD_TX_URB_CMD_MAX_LEN, |
534 | .rx_urb_cmd_max_len = ES58X_FD_RX_URB_CMD_MAX_LEN, |
535 | /* Size of internal device TX queue is 500. |
536 | * |
537 | * However, when reaching value around 278, the device's busy |
538 | * LED turns on and thus maximum value of 500 is never reached |
539 | * in practice. Also, when this value is too high, some error |
540 | * on the echo_msg were witnessed when the device is |
541 | * recovering from bus off. |
542 | * |
543 | * For above reasons, a value that would prevent the device |
544 | * from becoming busy was chosen. In practice, BQL would |
545 | * prevent the value from even getting closer to below |
546 | * maximum, so no impact on performance was measured. |
547 | */ |
548 | .fifo_mask = 255, /* echo_skb_max = 256 */ |
549 | .dql_min_limit = CAN_FRAME_LEN_MAX * 15, /* Empirical value. */ |
550 | .tx_bulk_max = ES58X_FD_TX_BULK_MAX, |
551 | .urb_cmd_header_len = ES58X_FD_URB_CMD_HEADER_LEN, |
552 | .rx_urb_max = ES58X_RX_URBS_MAX, |
553 | .tx_urb_max = ES58X_TX_URBS_MAX |
554 | }; |
555 | |
556 | const struct es58x_operators es58x_fd_ops = { |
557 | .get_msg_len = es58x_fd_get_msg_len, |
558 | .handle_urb_cmd = es58x_fd_handle_urb_cmd, |
559 | .fill_urb_header = es58x_fd_fill_urb_header, |
560 | .tx_can_msg = es58x_fd_tx_can_msg, |
561 | .enable_channel = es58x_fd_enable_channel, |
562 | .disable_channel = es58x_fd_disable_channel, |
563 | .reset_device = NULL, /* Not implemented in the device firmware. */ |
564 | .get_timestamp = es58x_fd_get_timestamp |
565 | }; |
566 | |