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 ret = es58x_check_msg_len(es58x_dev->dev, *rx_event_msg, msg_len); 177 if (ret) 178 return ret; 179 180 rx_event_msg = &es58x_fd_urb_cmd->rx_event_msg; 181 182 return es58x_rx_err_msg(netdev, rx_event_msg->error_code, 183 rx_event_msg->event_code, 184 get_unaligned_le64(&rx_event_msg->timestamp)); 185 } 186 187 static int es58x_fd_rx_cmd_ret_u32(struct net_device *netdev, 188 const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd, 189 enum es58x_ret_type cmd_ret_type) 190 { 191 struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev; 192 u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len); 193 int ret; 194 195 ret = es58x_check_msg_len(es58x_dev->dev, 196 es58x_fd_urb_cmd->rx_cmd_ret_le32, msg_len); 197 if (ret) 198 return ret; 199 200 return es58x_rx_cmd_ret_u32(netdev, cmd_ret_type, 201 get_unaligned_le32(&es58x_fd_urb_cmd->rx_cmd_ret_le32)); 202 } 203 204 static int es58x_fd_tx_ack_msg(struct net_device *netdev, 205 const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) 206 { 207 struct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev; 208 const struct es58x_fd_tx_ack_msg *tx_ack_msg; 209 u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len); 210 int ret; 211 212 tx_ack_msg = &es58x_fd_urb_cmd->tx_ack_msg; 213 ret = es58x_check_msg_len(es58x_dev->dev, *tx_ack_msg, msg_len); 214 if (ret) 215 return ret; 216 217 return es58x_tx_ack_msg(netdev, 218 get_unaligned_le16(&tx_ack_msg->tx_free_entries), 219 get_unaligned_le32(&tx_ack_msg->rx_cmd_ret_le32)); 220 } 221 222 static int es58x_fd_can_cmd_id(struct es58x_device *es58x_dev, 223 const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) 224 { 225 struct net_device *netdev; 226 int ret; 227 228 ret = es58x_get_netdev(es58x_dev, es58x_fd_urb_cmd->channel_idx, 229 ES58X_FD_CHANNEL_IDX_OFFSET, &netdev); 230 if (ret) 231 return ret; 232 233 switch ((enum es58x_fd_can_cmd_id)es58x_fd_urb_cmd->cmd_id) { 234 case ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL: 235 return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, 236 ES58X_RET_TYPE_ENABLE_CHANNEL); 237 238 case ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL: 239 return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, 240 ES58X_RET_TYPE_DISABLE_CHANNEL); 241 242 case ES58X_FD_CAN_CMD_ID_TX_MSG: 243 return es58x_fd_tx_ack_msg(netdev, es58x_fd_urb_cmd); 244 245 case ES58X_FD_CAN_CMD_ID_ECHO_MSG: 246 return es58x_fd_echo_msg(netdev, es58x_fd_urb_cmd); 247 248 case ES58X_FD_CAN_CMD_ID_RX_MSG: 249 return es58x_fd_rx_can_msg(netdev, es58x_fd_urb_cmd); 250 251 case ES58X_FD_CAN_CMD_ID_RESET_RX: 252 return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, 253 ES58X_RET_TYPE_RESET_RX); 254 255 case ES58X_FD_CAN_CMD_ID_RESET_TX: 256 return es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd, 257 ES58X_RET_TYPE_RESET_TX); 258 259 case ES58X_FD_CAN_CMD_ID_ERROR_OR_EVENT_MSG: 260 return es58x_fd_rx_event_msg(netdev, es58x_fd_urb_cmd); 261 262 default: 263 return -EBADRQC; 264 } 265 } 266 267 static int es58x_fd_device_cmd_id(struct es58x_device *es58x_dev, 268 const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd) 269 { 270 u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len); 271 int ret; 272 273 switch ((enum es58x_fd_dev_cmd_id)es58x_fd_urb_cmd->cmd_id) { 274 case ES58X_FD_DEV_CMD_ID_TIMESTAMP: 275 ret = es58x_check_msg_len(es58x_dev->dev, 276 es58x_fd_urb_cmd->timestamp, msg_len); 277 if (ret) 278 return ret; 279 es58x_rx_timestamp(es58x_dev, 280 get_unaligned_le64(&es58x_fd_urb_cmd->timestamp)); 281 return 0; 282 283 default: 284 return -EBADRQC; 285 } 286 } 287 288 static int es58x_fd_handle_urb_cmd(struct es58x_device *es58x_dev, 289 const union es58x_urb_cmd *urb_cmd) 290 { 291 const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd; 292 int ret; 293 294 es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd; 295 296 switch ((enum es58x_fd_cmd_type)es58x_fd_urb_cmd->cmd_type) { 297 case ES58X_FD_CMD_TYPE_CAN: 298 case ES58X_FD_CMD_TYPE_CANFD: 299 ret = es58x_fd_can_cmd_id(es58x_dev, es58x_fd_urb_cmd); 300 break; 301 302 case ES58X_FD_CMD_TYPE_DEVICE: 303 ret = es58x_fd_device_cmd_id(es58x_dev, es58x_fd_urb_cmd); 304 break; 305 306 default: 307 ret = -EBADRQC; 308 break; 309 } 310 311 if (ret == -EBADRQC) 312 dev_err(es58x_dev->dev, 313 "%s: Unknown command type (0x%02X) and command ID (0x%02X) combination\n", 314 __func__, es58x_fd_urb_cmd->cmd_type, 315 es58x_fd_urb_cmd->cmd_id); 316 317 return ret; 318 } 319 320 static void es58x_fd_fill_urb_header(union es58x_urb_cmd *urb_cmd, u8 cmd_type, 321 u8 cmd_id, u8 channel_idx, u16 msg_len) 322 { 323 struct es58x_fd_urb_cmd *es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd; 324 325 es58x_fd_urb_cmd->SOF = cpu_to_le16(es58x_fd_param.tx_start_of_frame); 326 es58x_fd_urb_cmd->cmd_type = cmd_type; 327 es58x_fd_urb_cmd->cmd_id = cmd_id; 328 es58x_fd_urb_cmd->channel_idx = channel_idx; 329 es58x_fd_urb_cmd->msg_len = cpu_to_le16(msg_len); 330 } 331 332 static int es58x_fd_tx_can_msg(struct es58x_priv *priv, 333 const struct sk_buff *skb) 334 { 335 struct es58x_device *es58x_dev = priv->es58x_dev; 336 union es58x_urb_cmd *urb_cmd = priv->tx_urb->transfer_buffer; 337 struct es58x_fd_urb_cmd *es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd; 338 struct can_frame *cf = (struct can_frame *)skb->data; 339 struct es58x_fd_tx_can_msg *tx_can_msg; 340 bool is_fd = can_is_canfd_skb(skb); 341 u16 msg_len; 342 int ret; 343 344 if (priv->tx_can_msg_cnt == 0) { 345 msg_len = 0; 346 es58x_fd_fill_urb_header(urb_cmd, 347 is_fd ? ES58X_FD_CMD_TYPE_CANFD 348 : ES58X_FD_CMD_TYPE_CAN, 349 ES58X_FD_CAN_CMD_ID_TX_MSG_NO_ACK, 350 priv->channel_idx, msg_len); 351 } else { 352 msg_len = es58x_fd_get_msg_len(urb_cmd); 353 } 354 355 ret = es58x_check_msg_max_len(es58x_dev->dev, 356 es58x_fd_urb_cmd->tx_can_msg_buf, 357 msg_len + sizeof(*tx_can_msg)); 358 if (ret) 359 return ret; 360 361 /* Fill message contents. */ 362 tx_can_msg = (typeof(tx_can_msg))&es58x_fd_urb_cmd->raw_msg[msg_len]; 363 tx_can_msg->packet_idx = (u8)priv->tx_head; 364 put_unaligned_le32(es58x_get_raw_can_id(cf), &tx_can_msg->can_id); 365 tx_can_msg->flags = (u8)es58x_get_flags(skb); 366 if (is_fd) 367 tx_can_msg->len = cf->len; 368 else 369 tx_can_msg->dlc = can_get_cc_dlc(cf, priv->can.ctrlmode); 370 memcpy(tx_can_msg->data, cf->data, cf->len); 371 372 /* Calculate new sizes */ 373 msg_len += es58x_fd_sizeof_rx_tx_msg(*tx_can_msg); 374 priv->tx_urb->transfer_buffer_length = es58x_get_urb_cmd_len(es58x_dev, 375 msg_len); 376 put_unaligned_le16(msg_len, &es58x_fd_urb_cmd->msg_len); 377 378 return 0; 379 } 380 381 static void es58x_fd_convert_bittiming(struct es58x_fd_bittiming *es58x_fd_bt, 382 struct can_bittiming *bt) 383 { 384 /* The actual value set in the hardware registers is one less 385 * than the functional value. 386 */ 387 const int offset = 1; 388 389 es58x_fd_bt->bitrate = cpu_to_le32(bt->bitrate); 390 es58x_fd_bt->tseg1 = 391 cpu_to_le16(bt->prop_seg + bt->phase_seg1 - offset); 392 es58x_fd_bt->tseg2 = cpu_to_le16(bt->phase_seg2 - offset); 393 es58x_fd_bt->brp = cpu_to_le16(bt->brp - offset); 394 es58x_fd_bt->sjw = cpu_to_le16(bt->sjw - offset); 395 } 396 397 static int es58x_fd_enable_channel(struct es58x_priv *priv) 398 { 399 struct es58x_device *es58x_dev = priv->es58x_dev; 400 struct net_device *netdev = es58x_dev->netdev[priv->channel_idx]; 401 struct es58x_fd_tx_conf_msg tx_conf_msg = { 0 }; 402 u32 ctrlmode; 403 size_t conf_len = 0; 404 405 es58x_fd_convert_bittiming(&tx_conf_msg.nominal_bittiming, 406 &priv->can.bittiming); 407 ctrlmode = priv->can.ctrlmode; 408 409 if (ctrlmode & CAN_CTRLMODE_3_SAMPLES) 410 tx_conf_msg.samples_per_bit = ES58X_SAMPLES_PER_BIT_THREE; 411 else 412 tx_conf_msg.samples_per_bit = ES58X_SAMPLES_PER_BIT_ONE; 413 tx_conf_msg.sync_edge = ES58X_SYNC_EDGE_SINGLE; 414 tx_conf_msg.physical_layer = ES58X_PHYSICAL_LAYER_HIGH_SPEED; 415 tx_conf_msg.echo_mode = ES58X_ECHO_ON; 416 if (ctrlmode & CAN_CTRLMODE_LISTENONLY) 417 tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_PASSIVE; 418 else 419 tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_ACTIVE; 420 421 if (ctrlmode & CAN_CTRLMODE_FD_NON_ISO) { 422 tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_FD_NON_ISO; 423 tx_conf_msg.canfd_enabled = 1; 424 } else if (ctrlmode & CAN_CTRLMODE_FD) { 425 tx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_FD; 426 tx_conf_msg.canfd_enabled = 1; 427 } 428 429 if (tx_conf_msg.canfd_enabled) { 430 es58x_fd_convert_bittiming(&tx_conf_msg.data_bittiming, 431 &priv->can.data_bittiming); 432 433 if (can_tdc_is_enabled(&priv->can)) { 434 tx_conf_msg.tdc_enabled = 1; 435 tx_conf_msg.tdco = cpu_to_le16(priv->can.tdc.tdco); 436 tx_conf_msg.tdcf = cpu_to_le16(priv->can.tdc.tdcf); 437 } 438 439 conf_len = ES58X_FD_CANFD_CONF_LEN; 440 } else { 441 conf_len = ES58X_FD_CAN_CONF_LEN; 442 } 443 444 return es58x_send_msg(es58x_dev, es58x_fd_cmd_type(netdev), 445 ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL, 446 &tx_conf_msg, conf_len, priv->channel_idx); 447 } 448 449 static int es58x_fd_disable_channel(struct es58x_priv *priv) 450 { 451 /* The type (ES58X_FD_CMD_TYPE_CAN or ES58X_FD_CMD_TYPE_CANFD) does 452 * not matter here. 453 */ 454 return es58x_send_msg(priv->es58x_dev, ES58X_FD_CMD_TYPE_CAN, 455 ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL, 456 ES58X_EMPTY_MSG, 0, priv->channel_idx); 457 } 458 459 static int es58x_fd_get_timestamp(struct es58x_device *es58x_dev) 460 { 461 return es58x_send_msg(es58x_dev, ES58X_FD_CMD_TYPE_DEVICE, 462 ES58X_FD_DEV_CMD_ID_TIMESTAMP, ES58X_EMPTY_MSG, 463 0, ES58X_CHANNEL_IDX_NA); 464 } 465 466 /* Nominal bittiming constants for ES582.1 and ES584.1 as specified in 467 * the microcontroller datasheet: "SAM E70/S70/V70/V71 Family" section 468 * 49.6.8 "MCAN Nominal Bit Timing and Prescaler Register" from 469 * Microchip. 470 * 471 * The values from the specification are the hardware register 472 * values. To convert them to the functional values, all ranges were 473 * incremented by 1 (e.g. range [0..n-1] changed to [1..n]). 474 */ 475 static const struct can_bittiming_const es58x_fd_nom_bittiming_const = { 476 .name = "ES582.1/ES584.1", 477 .tseg1_min = 2, 478 .tseg1_max = 256, 479 .tseg2_min = 2, 480 .tseg2_max = 128, 481 .sjw_max = 128, 482 .brp_min = 1, 483 .brp_max = 512, 484 .brp_inc = 1 485 }; 486 487 /* Data bittiming constants for ES582.1 and ES584.1 as specified in 488 * the microcontroller datasheet: "SAM E70/S70/V70/V71 Family" section 489 * 49.6.4 "MCAN Data Bit Timing and Prescaler Register" from 490 * Microchip. 491 */ 492 static const struct can_bittiming_const es58x_fd_data_bittiming_const = { 493 .name = "ES582.1/ES584.1", 494 .tseg1_min = 2, 495 .tseg1_max = 32, 496 .tseg2_min = 1, 497 .tseg2_max = 16, 498 .sjw_max = 8, 499 .brp_min = 1, 500 .brp_max = 32, 501 .brp_inc = 1 502 }; 503 504 /* Transmission Delay Compensation constants for ES582.1 and ES584.1 505 * as specified in the microcontroller datasheet: "SAM E70/S70/V70/V71 506 * Family" section 49.6.15 "MCAN Transmitter Delay Compensation 507 * Register" from Microchip. 508 */ 509 static const struct can_tdc_const es58x_tdc_const = { 510 .tdcv_min = 0, 511 .tdcv_max = 0, /* Manual mode not supported. */ 512 .tdco_min = 0, 513 .tdco_max = 127, 514 .tdcf_min = 0, 515 .tdcf_max = 127 516 }; 517 518 const struct es58x_parameters es58x_fd_param = { 519 .bittiming_const = &es58x_fd_nom_bittiming_const, 520 .data_bittiming_const = &es58x_fd_data_bittiming_const, 521 .tdc_const = &es58x_tdc_const, 522 /* The devices use NXP TJA1044G transievers which guarantee 523 * the timing for data rates up to 5 Mbps. Bitrates up to 8 524 * Mbps work in an optimal environment but are not recommended 525 * for production environment. 526 */ 527 .bitrate_max = 8 * MEGA /* BPS */, 528 .clock = {.freq = 80 * MEGA /* Hz */}, 529 .ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY | 530 CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO | 531 CAN_CTRLMODE_CC_LEN8_DLC | CAN_CTRLMODE_TDC_AUTO, 532 .tx_start_of_frame = 0xCEFA, /* FACE in little endian */ 533 .rx_start_of_frame = 0xFECA, /* CAFE in little endian */ 534 .tx_urb_cmd_max_len = ES58X_FD_TX_URB_CMD_MAX_LEN, 535 .rx_urb_cmd_max_len = ES58X_FD_RX_URB_CMD_MAX_LEN, 536 /* Size of internal device TX queue is 500. 537 * 538 * However, when reaching value around 278, the device's busy 539 * LED turns on and thus maximum value of 500 is never reached 540 * in practice. Also, when this value is too high, some error 541 * on the echo_msg were witnessed when the device is 542 * recovering from bus off. 543 * 544 * For above reasons, a value that would prevent the device 545 * from becoming busy was chosen. In practice, BQL would 546 * prevent the value from even getting closer to below 547 * maximum, so no impact on performance was measured. 548 */ 549 .fifo_mask = 255, /* echo_skb_max = 256 */ 550 .dql_min_limit = CAN_FRAME_LEN_MAX * 15, /* Empirical value. */ 551 .tx_bulk_max = ES58X_FD_TX_BULK_MAX, 552 .urb_cmd_header_len = ES58X_FD_URB_CMD_HEADER_LEN, 553 .rx_urb_max = ES58X_RX_URBS_MAX, 554 .tx_urb_max = ES58X_TX_URBS_MAX 555 }; 556 557 const struct es58x_operators es58x_fd_ops = { 558 .get_msg_len = es58x_fd_get_msg_len, 559 .handle_urb_cmd = es58x_fd_handle_urb_cmd, 560 .fill_urb_header = es58x_fd_fill_urb_header, 561 .tx_can_msg = es58x_fd_tx_can_msg, 562 .enable_channel = es58x_fd_enable_channel, 563 .disable_channel = es58x_fd_disable_channel, 564 .reset_device = NULL, /* Not implemented in the device firmware. */ 565 .get_timestamp = es58x_fd_get_timestamp 566 }; 567