1 // SPDX-License-Identifier: GPL-2.0 2 3 /* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces. 4 * 5 * File es581_4.c: Adds support to ETAS ES581.4. 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 #include <asm/unaligned.h> 13 #include <linux/kernel.h> 14 #include <linux/units.h> 15 16 #include "es58x_core.h" 17 #include "es581_4.h" 18 19 /** 20 * es581_4_sizeof_rx_tx_msg() - Calculate the actual length of the 21 * structure of a rx or tx message. 22 * @msg: message of variable length, must have a dlc field. 23 * 24 * Even if RTR frames have actually no payload, the ES58X devices 25 * still expect it. Must be a macro in order to accept several types 26 * (struct es581_4_tx_can_msg and struct es581_4_rx_can_msg) as an 27 * input. 28 * 29 * Return: length of the message. 30 */ 31 #define es581_4_sizeof_rx_tx_msg(msg) \ 32 offsetof(typeof(msg), data[can_cc_dlc2len((msg).dlc)]) 33 34 static u16 es581_4_get_msg_len(const union es58x_urb_cmd *urb_cmd) 35 { 36 return get_unaligned_le16(&urb_cmd->es581_4_urb_cmd.msg_len); 37 } 38 39 static int es581_4_echo_msg(struct es58x_device *es58x_dev, 40 const struct es581_4_urb_cmd *es581_4_urb_cmd) 41 { 42 struct net_device *netdev; 43 const struct es581_4_bulk_echo_msg *bulk_echo_msg; 44 const struct es581_4_echo_msg *echo_msg; 45 u64 *tstamps = es58x_dev->timestamps; 46 u16 msg_len; 47 u32 first_packet_idx, packet_idx; 48 unsigned int dropped = 0; 49 int i, num_element, ret; 50 51 bulk_echo_msg = &es581_4_urb_cmd->bulk_echo_msg; 52 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len) - 53 sizeof(bulk_echo_msg->channel_no); 54 num_element = es58x_msg_num_element(es58x_dev->dev, 55 bulk_echo_msg->echo_msg, msg_len); 56 if (num_element <= 0) 57 return num_element; 58 59 ret = es58x_get_netdev(es58x_dev, bulk_echo_msg->channel_no, 60 ES581_4_CHANNEL_IDX_OFFSET, &netdev); 61 if (ret) 62 return ret; 63 64 echo_msg = &bulk_echo_msg->echo_msg[0]; 65 first_packet_idx = get_unaligned_le32(&echo_msg->packet_idx); 66 packet_idx = first_packet_idx; 67 for (i = 0; i < num_element; i++) { 68 u32 tmp_idx; 69 70 echo_msg = &bulk_echo_msg->echo_msg[i]; 71 tmp_idx = get_unaligned_le32(&echo_msg->packet_idx); 72 if (tmp_idx == packet_idx - 1) { 73 if (net_ratelimit()) 74 netdev_warn(netdev, 75 "Received echo packet idx %u twice\n", 76 packet_idx - 1); 77 dropped++; 78 continue; 79 } 80 if (tmp_idx != packet_idx) { 81 netdev_err(netdev, "Echo packet idx jumped from %u to %u\n", 82 packet_idx - 1, echo_msg->packet_idx); 83 return -EBADMSG; 84 } 85 86 tstamps[i] = get_unaligned_le64(&echo_msg->timestamp); 87 packet_idx++; 88 } 89 90 netdev->stats.tx_dropped += dropped; 91 return es58x_can_get_echo_skb(netdev, first_packet_idx, 92 tstamps, num_element - dropped); 93 } 94 95 static int es581_4_rx_can_msg(struct es58x_device *es58x_dev, 96 const struct es581_4_urb_cmd *es581_4_urb_cmd, 97 u16 msg_len) 98 { 99 const struct device *dev = es58x_dev->dev; 100 struct net_device *netdev; 101 int pkts, num_element, channel_no, ret; 102 103 num_element = es58x_msg_num_element(dev, es581_4_urb_cmd->rx_can_msg, 104 msg_len); 105 if (num_element <= 0) 106 return num_element; 107 108 channel_no = es581_4_urb_cmd->rx_can_msg[0].channel_no; 109 ret = es58x_get_netdev(es58x_dev, channel_no, 110 ES581_4_CHANNEL_IDX_OFFSET, &netdev); 111 if (ret) 112 return ret; 113 114 if (!netif_running(netdev)) { 115 if (net_ratelimit()) 116 netdev_info(netdev, 117 "%s: %s is down, dropping %d rx packets\n", 118 __func__, netdev->name, num_element); 119 netdev->stats.rx_dropped += num_element; 120 return 0; 121 } 122 123 for (pkts = 0; pkts < num_element; pkts++) { 124 const struct es581_4_rx_can_msg *rx_can_msg = 125 &es581_4_urb_cmd->rx_can_msg[pkts]; 126 u64 tstamp = get_unaligned_le64(&rx_can_msg->timestamp); 127 canid_t can_id = get_unaligned_le32(&rx_can_msg->can_id); 128 129 if (channel_no != rx_can_msg->channel_no) 130 return -EBADMSG; 131 132 ret = es58x_rx_can_msg(netdev, tstamp, rx_can_msg->data, 133 can_id, rx_can_msg->flags, 134 rx_can_msg->dlc); 135 if (ret) 136 break; 137 } 138 139 return ret; 140 } 141 142 static int es581_4_rx_err_msg(struct es58x_device *es58x_dev, 143 const struct es581_4_rx_err_msg *rx_err_msg) 144 { 145 struct net_device *netdev; 146 enum es58x_err error = get_unaligned_le32(&rx_err_msg->error); 147 int ret; 148 149 ret = es58x_get_netdev(es58x_dev, rx_err_msg->channel_no, 150 ES581_4_CHANNEL_IDX_OFFSET, &netdev); 151 if (ret) 152 return ret; 153 154 return es58x_rx_err_msg(netdev, error, 0, 155 get_unaligned_le64(&rx_err_msg->timestamp)); 156 } 157 158 static int es581_4_rx_event_msg(struct es58x_device *es58x_dev, 159 const struct es581_4_rx_event_msg *rx_event_msg) 160 { 161 struct net_device *netdev; 162 enum es58x_event event = get_unaligned_le32(&rx_event_msg->event); 163 int ret; 164 165 ret = es58x_get_netdev(es58x_dev, rx_event_msg->channel_no, 166 ES581_4_CHANNEL_IDX_OFFSET, &netdev); 167 if (ret) 168 return ret; 169 170 return es58x_rx_err_msg(netdev, 0, event, 171 get_unaligned_le64(&rx_event_msg->timestamp)); 172 } 173 174 static int es581_4_rx_cmd_ret_u32(struct es58x_device *es58x_dev, 175 const struct es581_4_urb_cmd *es581_4_urb_cmd, 176 enum es58x_ret_type ret_type) 177 { 178 struct net_device *netdev; 179 const struct es581_4_rx_cmd_ret *rx_cmd_ret; 180 u16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len); 181 int ret; 182 183 ret = es58x_check_msg_len(es58x_dev->dev, 184 es581_4_urb_cmd->rx_cmd_ret, msg_len); 185 if (ret) 186 return ret; 187 188 rx_cmd_ret = &es581_4_urb_cmd->rx_cmd_ret; 189 190 ret = es58x_get_netdev(es58x_dev, rx_cmd_ret->channel_no, 191 ES581_4_CHANNEL_IDX_OFFSET, &netdev); 192 if (ret) 193 return ret; 194 195 return es58x_rx_cmd_ret_u32(netdev, ret_type, 196 get_unaligned_le32(&rx_cmd_ret->rx_cmd_ret_le32)); 197 } 198 199 static int es581_4_tx_ack_msg(struct es58x_device *es58x_dev, 200 const struct es581_4_urb_cmd *es581_4_urb_cmd) 201 { 202 struct net_device *netdev; 203 const struct es581_4_tx_ack_msg *tx_ack_msg; 204 u16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len); 205 int ret; 206 207 tx_ack_msg = &es581_4_urb_cmd->tx_ack_msg; 208 ret = es58x_check_msg_len(es58x_dev->dev, *tx_ack_msg, msg_len); 209 if (ret) 210 return ret; 211 212 if (tx_ack_msg->rx_cmd_ret_u8 != ES58X_RET_U8_OK) 213 return es58x_rx_cmd_ret_u8(es58x_dev->dev, 214 ES58X_RET_TYPE_TX_MSG, 215 tx_ack_msg->rx_cmd_ret_u8); 216 217 ret = es58x_get_netdev(es58x_dev, tx_ack_msg->channel_no, 218 ES581_4_CHANNEL_IDX_OFFSET, &netdev); 219 if (ret) 220 return ret; 221 222 return es58x_tx_ack_msg(netdev, 223 get_unaligned_le16(&tx_ack_msg->tx_free_entries), 224 ES58X_RET_U32_OK); 225 } 226 227 static int es581_4_dispatch_rx_cmd(struct es58x_device *es58x_dev, 228 const struct es581_4_urb_cmd *es581_4_urb_cmd) 229 { 230 const struct device *dev = es58x_dev->dev; 231 u16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len); 232 enum es581_4_rx_type rx_type = es581_4_urb_cmd->rx_can_msg[0].rx_type; 233 int ret = 0; 234 235 switch (rx_type) { 236 case ES581_4_RX_TYPE_MESSAGE: 237 return es581_4_rx_can_msg(es58x_dev, es581_4_urb_cmd, msg_len); 238 239 case ES581_4_RX_TYPE_ERROR: 240 ret = es58x_check_msg_len(dev, es581_4_urb_cmd->rx_err_msg, 241 msg_len); 242 if (ret < 0) 243 return ret; 244 return es581_4_rx_err_msg(es58x_dev, 245 &es581_4_urb_cmd->rx_err_msg); 246 247 case ES581_4_RX_TYPE_EVENT: 248 ret = es58x_check_msg_len(dev, es581_4_urb_cmd->rx_event_msg, 249 msg_len); 250 if (ret < 0) 251 return ret; 252 return es581_4_rx_event_msg(es58x_dev, 253 &es581_4_urb_cmd->rx_event_msg); 254 255 default: 256 dev_err(dev, "%s: Unknown rx_type 0x%02X\n", __func__, rx_type); 257 return -EBADRQC; 258 } 259 } 260 261 static int es581_4_handle_urb_cmd(struct es58x_device *es58x_dev, 262 const union es58x_urb_cmd *urb_cmd) 263 { 264 const struct es581_4_urb_cmd *es581_4_urb_cmd; 265 struct device *dev = es58x_dev->dev; 266 u16 msg_len = es581_4_get_msg_len(urb_cmd); 267 int ret; 268 269 es581_4_urb_cmd = &urb_cmd->es581_4_urb_cmd; 270 271 if (es581_4_urb_cmd->cmd_type != ES581_4_CAN_COMMAND_TYPE) { 272 dev_err(dev, "%s: Unknown command type (0x%02X)\n", 273 __func__, es581_4_urb_cmd->cmd_type); 274 return -EBADRQC; 275 } 276 277 switch ((enum es581_4_cmd_id)es581_4_urb_cmd->cmd_id) { 278 case ES581_4_CMD_ID_SET_BITTIMING: 279 return es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd, 280 ES58X_RET_TYPE_SET_BITTIMING); 281 282 case ES581_4_CMD_ID_ENABLE_CHANNEL: 283 return es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd, 284 ES58X_RET_TYPE_ENABLE_CHANNEL); 285 286 case ES581_4_CMD_ID_TX_MSG: 287 return es581_4_tx_ack_msg(es58x_dev, es581_4_urb_cmd); 288 289 case ES581_4_CMD_ID_RX_MSG: 290 return es581_4_dispatch_rx_cmd(es58x_dev, es581_4_urb_cmd); 291 292 case ES581_4_CMD_ID_RESET_RX: 293 ret = es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd, 294 ES58X_RET_TYPE_RESET_RX); 295 return ret; 296 297 case ES581_4_CMD_ID_RESET_TX: 298 ret = es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd, 299 ES58X_RET_TYPE_RESET_TX); 300 return ret; 301 302 case ES581_4_CMD_ID_DISABLE_CHANNEL: 303 return es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd, 304 ES58X_RET_TYPE_DISABLE_CHANNEL); 305 306 case ES581_4_CMD_ID_TIMESTAMP: 307 ret = es58x_check_msg_len(dev, es581_4_urb_cmd->timestamp, 308 msg_len); 309 if (ret < 0) 310 return ret; 311 es58x_rx_timestamp(es58x_dev, 312 get_unaligned_le64(&es581_4_urb_cmd->timestamp)); 313 return 0; 314 315 case ES581_4_CMD_ID_ECHO: 316 return es581_4_echo_msg(es58x_dev, es581_4_urb_cmd); 317 318 case ES581_4_CMD_ID_DEVICE_ERR: 319 ret = es58x_check_msg_len(dev, es581_4_urb_cmd->rx_cmd_ret_u8, 320 msg_len); 321 if (ret) 322 return ret; 323 return es58x_rx_cmd_ret_u8(dev, ES58X_RET_TYPE_DEVICE_ERR, 324 es581_4_urb_cmd->rx_cmd_ret_u8); 325 326 default: 327 dev_warn(dev, "%s: Unexpected command ID: 0x%02X\n", 328 __func__, es581_4_urb_cmd->cmd_id); 329 return -EBADRQC; 330 } 331 } 332 333 static void es581_4_fill_urb_header(union es58x_urb_cmd *urb_cmd, u8 cmd_type, 334 u8 cmd_id, u8 channel_idx, u16 msg_len) 335 { 336 struct es581_4_urb_cmd *es581_4_urb_cmd = &urb_cmd->es581_4_urb_cmd; 337 338 es581_4_urb_cmd->SOF = cpu_to_le16(es581_4_param.tx_start_of_frame); 339 es581_4_urb_cmd->cmd_type = cmd_type; 340 es581_4_urb_cmd->cmd_id = cmd_id; 341 es581_4_urb_cmd->msg_len = cpu_to_le16(msg_len); 342 } 343 344 static int es581_4_tx_can_msg(struct es58x_priv *priv, 345 const struct sk_buff *skb) 346 { 347 struct es58x_device *es58x_dev = priv->es58x_dev; 348 union es58x_urb_cmd *urb_cmd = priv->tx_urb->transfer_buffer; 349 struct es581_4_urb_cmd *es581_4_urb_cmd = &urb_cmd->es581_4_urb_cmd; 350 struct can_frame *cf = (struct can_frame *)skb->data; 351 struct es581_4_tx_can_msg *tx_can_msg; 352 u16 msg_len; 353 int ret; 354 355 if (can_is_canfd_skb(skb)) 356 return -EMSGSIZE; 357 358 if (priv->tx_can_msg_cnt == 0) { 359 msg_len = sizeof(es581_4_urb_cmd->bulk_tx_can_msg.num_can_msg); 360 es581_4_fill_urb_header(urb_cmd, ES581_4_CAN_COMMAND_TYPE, 361 ES581_4_CMD_ID_TX_MSG, 362 priv->channel_idx, msg_len); 363 es581_4_urb_cmd->bulk_tx_can_msg.num_can_msg = 0; 364 } else { 365 msg_len = es581_4_get_msg_len(urb_cmd); 366 } 367 368 ret = es58x_check_msg_max_len(es58x_dev->dev, 369 es581_4_urb_cmd->bulk_tx_can_msg, 370 msg_len + sizeof(*tx_can_msg)); 371 if (ret) 372 return ret; 373 374 /* Fill message contents. */ 375 tx_can_msg = (typeof(tx_can_msg))&es581_4_urb_cmd->raw_msg[msg_len]; 376 put_unaligned_le32(es58x_get_raw_can_id(cf), &tx_can_msg->can_id); 377 put_unaligned_le32(priv->tx_head, &tx_can_msg->packet_idx); 378 put_unaligned_le16((u16)es58x_get_flags(skb), &tx_can_msg->flags); 379 tx_can_msg->channel_no = priv->channel_idx + ES581_4_CHANNEL_IDX_OFFSET; 380 tx_can_msg->dlc = can_get_cc_dlc(cf, priv->can.ctrlmode); 381 382 memcpy(tx_can_msg->data, cf->data, cf->len); 383 384 /* Calculate new sizes. */ 385 es581_4_urb_cmd->bulk_tx_can_msg.num_can_msg++; 386 msg_len += es581_4_sizeof_rx_tx_msg(*tx_can_msg); 387 priv->tx_urb->transfer_buffer_length = es58x_get_urb_cmd_len(es58x_dev, 388 msg_len); 389 es581_4_urb_cmd->msg_len = cpu_to_le16(msg_len); 390 391 return 0; 392 } 393 394 static int es581_4_set_bittiming(struct es58x_priv *priv) 395 { 396 struct es581_4_tx_conf_msg tx_conf_msg = { 0 }; 397 struct can_bittiming *bt = &priv->can.bittiming; 398 399 tx_conf_msg.bitrate = cpu_to_le32(bt->bitrate); 400 /* bt->sample_point is in tenth of percent. Convert it to percent. */ 401 tx_conf_msg.sample_point = cpu_to_le32(bt->sample_point / 10U); 402 tx_conf_msg.samples_per_bit = cpu_to_le32(ES58X_SAMPLES_PER_BIT_ONE); 403 tx_conf_msg.bit_time = cpu_to_le32(can_bit_time(bt)); 404 tx_conf_msg.sjw = cpu_to_le32(bt->sjw); 405 tx_conf_msg.sync_edge = cpu_to_le32(ES58X_SYNC_EDGE_SINGLE); 406 tx_conf_msg.physical_layer = 407 cpu_to_le32(ES58X_PHYSICAL_LAYER_HIGH_SPEED); 408 tx_conf_msg.echo_mode = cpu_to_le32(ES58X_ECHO_ON); 409 tx_conf_msg.channel_no = priv->channel_idx + ES581_4_CHANNEL_IDX_OFFSET; 410 411 return es58x_send_msg(priv->es58x_dev, ES581_4_CAN_COMMAND_TYPE, 412 ES581_4_CMD_ID_SET_BITTIMING, &tx_conf_msg, 413 sizeof(tx_conf_msg), priv->channel_idx); 414 } 415 416 static int es581_4_enable_channel(struct es58x_priv *priv) 417 { 418 int ret; 419 u8 msg = priv->channel_idx + ES581_4_CHANNEL_IDX_OFFSET; 420 421 ret = es581_4_set_bittiming(priv); 422 if (ret) 423 return ret; 424 425 return es58x_send_msg(priv->es58x_dev, ES581_4_CAN_COMMAND_TYPE, 426 ES581_4_CMD_ID_ENABLE_CHANNEL, &msg, sizeof(msg), 427 priv->channel_idx); 428 } 429 430 static int es581_4_disable_channel(struct es58x_priv *priv) 431 { 432 u8 msg = priv->channel_idx + ES581_4_CHANNEL_IDX_OFFSET; 433 434 return es58x_send_msg(priv->es58x_dev, ES581_4_CAN_COMMAND_TYPE, 435 ES581_4_CMD_ID_DISABLE_CHANNEL, &msg, sizeof(msg), 436 priv->channel_idx); 437 } 438 439 static int es581_4_reset_device(struct es58x_device *es58x_dev) 440 { 441 return es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE, 442 ES581_4_CMD_ID_RESET_DEVICE, 443 ES58X_EMPTY_MSG, 0, ES58X_CHANNEL_IDX_NA); 444 } 445 446 static int es581_4_get_timestamp(struct es58x_device *es58x_dev) 447 { 448 return es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE, 449 ES581_4_CMD_ID_TIMESTAMP, 450 ES58X_EMPTY_MSG, 0, ES58X_CHANNEL_IDX_NA); 451 } 452 453 /* Nominal bittiming constants for ES581.4 as specified in the 454 * microcontroller datasheet: "Stellaris(R) LM3S5B91 Microcontroller" 455 * table 17-4 "CAN Protocol Ranges" from Texas Instruments. 456 */ 457 static const struct can_bittiming_const es581_4_bittiming_const = { 458 .name = "ES581.4", 459 .tseg1_min = 1, 460 .tseg1_max = 8, 461 .tseg2_min = 1, 462 .tseg2_max = 8, 463 .sjw_max = 4, 464 .brp_min = 1, 465 .brp_max = 128, 466 .brp_inc = 1 467 }; 468 469 const struct es58x_parameters es581_4_param = { 470 .bittiming_const = &es581_4_bittiming_const, 471 .data_bittiming_const = NULL, 472 .tdc_const = NULL, 473 .bitrate_max = 1 * MEGA /* BPS */, 474 .clock = {.freq = 50 * MEGA /* Hz */}, 475 .ctrlmode_supported = CAN_CTRLMODE_CC_LEN8_DLC, 476 .tx_start_of_frame = 0xAFAF, 477 .rx_start_of_frame = 0xFAFA, 478 .tx_urb_cmd_max_len = ES581_4_TX_URB_CMD_MAX_LEN, 479 .rx_urb_cmd_max_len = ES581_4_RX_URB_CMD_MAX_LEN, 480 /* Size of internal device TX queue is 330. 481 * 482 * However, we witnessed some ES58X_ERR_PROT_CRC errors from 483 * the device and thus, echo_skb_max was lowered to the 484 * empirical value of 75 which seems stable and then rounded 485 * down to become a power of two. 486 * 487 * Root cause of those ES58X_ERR_PROT_CRC errors is still 488 * unclear. 489 */ 490 .fifo_mask = 63, /* echo_skb_max = 64 */ 491 .dql_min_limit = CAN_FRAME_LEN_MAX * 50, /* Empirical value. */ 492 .tx_bulk_max = ES581_4_TX_BULK_MAX, 493 .urb_cmd_header_len = ES581_4_URB_CMD_HEADER_LEN, 494 .rx_urb_max = ES58X_RX_URBS_MAX, 495 .tx_urb_max = ES58X_TX_URBS_MAX 496 }; 497 498 const struct es58x_operators es581_4_ops = { 499 .get_msg_len = es581_4_get_msg_len, 500 .handle_urb_cmd = es581_4_handle_urb_cmd, 501 .fill_urb_header = es581_4_fill_urb_header, 502 .tx_can_msg = es581_4_tx_can_msg, 503 .enable_channel = es581_4_enable_channel, 504 .disable_channel = es581_4_disable_channel, 505 .reset_device = es581_4_reset_device, 506 .get_timestamp = es581_4_get_timestamp 507 }; 508