| 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 <[email protected]> |
| 12 |
*/ |
| 13 |
|
| 14 |
#include <linux/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(&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.fd.data_bittiming); |
| 431 |
|
| 432 |
if (can_fd_tdc_is_enabled(&priv->can)) { |
| 433 |
tx_conf_msg.tdc_enabled = 1; |
| 434 |
tx_conf_msg.tdco = cpu_to_le16(priv->can.fd.tdc.tdco); |
| 435 |
tx_conf_msg.tdcf = cpu_to_le16(priv->can.fd.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 |
}; |