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, 2021 Vincent Mailhol <mailhol.vincent@wanadoo.fr> 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/units.h> 16 #include <asm/unaligned.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(&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(&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(netdev, "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(&echo_msg[i].timestamp); 92 rcv_packet_idx++; 93 } 94 95 return es58x_can_get_echo_skb(netdev, priv->tx_tail, tstamps, 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(&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(netdev, 125 "%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(netdev, 132 "%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(netdev)) { 138 u64 tstamp = get_unaligned_le64(&rx_can_msg->timestamp); 139 canid_t can_id = get_unaligned_le32(&rx_can_msg->can_id); 140 u8 dlc; 141 142 if (is_can_fd) 143 dlc = can_fd_len2dlc(rx_can_msg->len); 144 else 145 dlc = rx_can_msg->dlc; 146 147 ret = es58x_rx_can_msg(netdev, tstamp, rx_can_msg->data, 148 can_id, 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(netdev)) { 158 if (net_ratelimit()) 159 netdev_info(netdev, 160 "%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(&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, rx_event_msg->error_code, 182 rx_event_msg->event_code, 183 get_unaligned_le64(&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(&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 get_unaligned_le32(&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(&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 get_unaligned_le16(&tx_ack_msg->tx_free_entries), 218 get_unaligned_le32(&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, es58x_fd_urb_cmd->channel_idx, 228 ES58X_FD_CHANNEL_IDX_OFFSET, &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 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 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 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 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(&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 get_unaligned_le64(&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 es58x_fd_fill_urb_header(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 is_fd ? ES58X_FD_CMD_TYPE_CANFD 347 : ES58X_FD_CMD_TYPE_CAN, 348 ES58X_FD_CAN_CMD_ID_TX_MSG_NO_ACK, 349 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(es58x_get_raw_can_id(cf), &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, 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(msg_len, &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(&tx_conf_msg.nominal_bittiming, 405 &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(&tx_conf_msg.data_bittiming, 430 &priv->can.data_bittiming); 431 432 if (can_tdc_is_enabled(&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, es58x_fd_cmd_type(netdev), 444 ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL, 445 &tx_conf_msg, conf_len, 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(priv->es58x_dev, ES58X_FD_CMD_TYPE_CAN, 454 ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL, 455 ES58X_EMPTY_MSG, 0, 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, ES58X_FD_CMD_TYPE_DEVICE, 461 ES58X_FD_DEV_CMD_ID_TIMESTAMP, ES58X_EMPTY_MSG, 462 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