1 // SPDX-License-Identifier: GPL-2.0 2 /* Parts of this driver are based on the following: 3 * - Kvaser linux mhydra driver (version 5.24) 4 * - CAN driver for esd CAN-USB/2 5 * 6 * Copyright (C) 2018 KVASER AB, Sweden. All rights reserved. 7 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh 8 * 9 * Known issues: 10 * - Transition from CAN_STATE_ERROR_WARNING to CAN_STATE_ERROR_ACTIVE is only 11 * reported after a call to do_get_berr_counter(), since firmware does not 12 * distinguish between ERROR_WARNING and ERROR_ACTIVE. 13 * - Hardware timestamps are not set for CAN Tx frames. 14 */ 15 16 #include <linux/completion.h> 17 #include <linux/device.h> 18 #include <linux/gfp.h> 19 #include <linux/jiffies.h> 20 #include <linux/kernel.h> 21 #include <linux/netdevice.h> 22 #include <linux/spinlock.h> 23 #include <linux/string.h> 24 #include <linux/types.h> 25 #include <linux/units.h> 26 #include <linux/usb.h> 27 28 #include <linux/can.h> 29 #include <linux/can/dev.h> 30 #include <linux/can/error.h> 31 #include <linux/can/netlink.h> 32 33 #include "kvaser_usb.h" 34 35 /* Forward declarations */ 36 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_kcan; 37 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_flexc; 38 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_rt; 39 40 #define KVASER_USB_HYDRA_BULK_EP_IN_ADDR 0x82 41 #define KVASER_USB_HYDRA_BULK_EP_OUT_ADDR 0x02 42 43 #define KVASER_USB_HYDRA_MAX_TRANSID 0xff 44 #define KVASER_USB_HYDRA_MIN_TRANSID 0x01 45 46 /* Minihydra command IDs */ 47 #define CMD_SET_BUSPARAMS_REQ 16 48 #define CMD_GET_CHIP_STATE_REQ 19 49 #define CMD_CHIP_STATE_EVENT 20 50 #define CMD_SET_DRIVERMODE_REQ 21 51 #define CMD_START_CHIP_REQ 26 52 #define CMD_START_CHIP_RESP 27 53 #define CMD_STOP_CHIP_REQ 28 54 #define CMD_STOP_CHIP_RESP 29 55 #define CMD_TX_CAN_MESSAGE 33 56 #define CMD_GET_CARD_INFO_REQ 34 57 #define CMD_GET_CARD_INFO_RESP 35 58 #define CMD_GET_SOFTWARE_INFO_REQ 38 59 #define CMD_GET_SOFTWARE_INFO_RESP 39 60 #define CMD_ERROR_EVENT 45 61 #define CMD_FLUSH_QUEUE 48 62 #define CMD_TX_ACKNOWLEDGE 50 63 #define CMD_FLUSH_QUEUE_RESP 66 64 #define CMD_SET_BUSPARAMS_FD_REQ 69 65 #define CMD_SET_BUSPARAMS_FD_RESP 70 66 #define CMD_SET_BUSPARAMS_RESP 85 67 #define CMD_GET_CAPABILITIES_REQ 95 68 #define CMD_GET_CAPABILITIES_RESP 96 69 #define CMD_RX_MESSAGE 106 70 #define CMD_MAP_CHANNEL_REQ 200 71 #define CMD_MAP_CHANNEL_RESP 201 72 #define CMD_GET_SOFTWARE_DETAILS_REQ 202 73 #define CMD_GET_SOFTWARE_DETAILS_RESP 203 74 #define CMD_EXTENDED 255 75 76 /* Minihydra extended command IDs */ 77 #define CMD_TX_CAN_MESSAGE_FD 224 78 #define CMD_TX_ACKNOWLEDGE_FD 225 79 #define CMD_RX_MESSAGE_FD 226 80 81 /* Hydra commands are handled by different threads in firmware. 82 * The threads are denoted hydra entity (HE). Each HE got a unique 6-bit 83 * address. The address is used in hydra commands to get/set source and 84 * destination HE. There are two predefined HE addresses, the remaining 85 * addresses are different between devices and firmware versions. Hence, we need 86 * to enumerate the addresses (see kvaser_usb_hydra_map_channel()). 87 */ 88 89 /* Well-known HE addresses */ 90 #define KVASER_USB_HYDRA_HE_ADDRESS_ROUTER 0x00 91 #define KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL 0x3e 92 93 #define KVASER_USB_HYDRA_TRANSID_CANHE 0x40 94 #define KVASER_USB_HYDRA_TRANSID_SYSDBG 0x61 95 96 struct kvaser_cmd_map_ch_req { 97 char name[16]; 98 u8 channel; 99 u8 reserved[11]; 100 } __packed; 101 102 struct kvaser_cmd_map_ch_res { 103 u8 he_addr; 104 u8 channel; 105 u8 reserved[26]; 106 } __packed; 107 108 struct kvaser_cmd_card_info { 109 __le32 serial_number; 110 __le32 clock_res; 111 __le32 mfg_date; 112 __le32 ean[2]; 113 u8 hw_version; 114 u8 usb_mode; 115 u8 hw_type; 116 u8 reserved0; 117 u8 nchannels; 118 u8 reserved1[3]; 119 } __packed; 120 121 struct kvaser_cmd_sw_info { 122 u8 reserved0[8]; 123 __le16 max_outstanding_tx; 124 u8 reserved1[18]; 125 } __packed; 126 127 struct kvaser_cmd_sw_detail_req { 128 u8 use_ext_cmd; 129 u8 reserved[27]; 130 } __packed; 131 132 /* Software detail flags */ 133 #define KVASER_USB_HYDRA_SW_FLAG_FW_BETA BIT(2) 134 #define KVASER_USB_HYDRA_SW_FLAG_FW_BAD BIT(4) 135 #define KVASER_USB_HYDRA_SW_FLAG_FREQ_80M BIT(5) 136 #define KVASER_USB_HYDRA_SW_FLAG_EXT_CMD BIT(9) 137 #define KVASER_USB_HYDRA_SW_FLAG_CANFD BIT(10) 138 #define KVASER_USB_HYDRA_SW_FLAG_NONISO BIT(11) 139 #define KVASER_USB_HYDRA_SW_FLAG_EXT_CAP BIT(12) 140 #define KVASER_USB_HYDRA_SW_FLAG_CAN_FREQ_80M BIT(13) 141 struct kvaser_cmd_sw_detail_res { 142 __le32 sw_flags; 143 __le32 sw_version; 144 __le32 sw_name; 145 __le32 ean[2]; 146 __le32 max_bitrate; 147 u8 reserved[4]; 148 } __packed; 149 150 /* Sub commands for cap_req and cap_res */ 151 #define KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE 0x02 152 #define KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT 0x05 153 #define KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT 0x06 154 struct kvaser_cmd_cap_req { 155 __le16 cap_cmd; 156 u8 reserved[26]; 157 } __packed; 158 159 /* Status codes for cap_res */ 160 #define KVASER_USB_HYDRA_CAP_STAT_OK 0x00 161 #define KVASER_USB_HYDRA_CAP_STAT_NOT_IMPL 0x01 162 #define KVASER_USB_HYDRA_CAP_STAT_UNAVAIL 0x02 163 struct kvaser_cmd_cap_res { 164 __le16 cap_cmd; 165 __le16 status; 166 __le32 mask; 167 __le32 value; 168 u8 reserved[16]; 169 } __packed; 170 171 /* CMD_ERROR_EVENT error codes */ 172 #define KVASER_USB_HYDRA_ERROR_EVENT_CAN 0x01 173 #define KVASER_USB_HYDRA_ERROR_EVENT_PARAM 0x09 174 struct kvaser_cmd_error_event { 175 __le16 timestamp[3]; 176 u8 reserved; 177 u8 error_code; 178 __le16 info1; 179 __le16 info2; 180 } __packed; 181 182 /* Chip state status flags. Used for chip_state_event and err_frame_data. */ 183 #define KVASER_USB_HYDRA_BUS_ERR_ACT 0x00 184 #define KVASER_USB_HYDRA_BUS_ERR_PASS BIT(5) 185 #define KVASER_USB_HYDRA_BUS_BUS_OFF BIT(6) 186 struct kvaser_cmd_chip_state_event { 187 __le16 timestamp[3]; 188 u8 tx_err_counter; 189 u8 rx_err_counter; 190 u8 bus_status; 191 u8 reserved[19]; 192 } __packed; 193 194 /* Busparam modes */ 195 #define KVASER_USB_HYDRA_BUS_MODE_CAN 0x00 196 #define KVASER_USB_HYDRA_BUS_MODE_CANFD_ISO 0x01 197 #define KVASER_USB_HYDRA_BUS_MODE_NONISO 0x02 198 struct kvaser_cmd_set_busparams { 199 __le32 bitrate; 200 u8 tseg1; 201 u8 tseg2; 202 u8 sjw; 203 u8 nsamples; 204 u8 reserved0[4]; 205 __le32 bitrate_d; 206 u8 tseg1_d; 207 u8 tseg2_d; 208 u8 sjw_d; 209 u8 nsamples_d; 210 u8 canfd_mode; 211 u8 reserved1[7]; 212 } __packed; 213 214 /* Ctrl modes */ 215 #define KVASER_USB_HYDRA_CTRLMODE_NORMAL 0x01 216 #define KVASER_USB_HYDRA_CTRLMODE_LISTEN 0x02 217 struct kvaser_cmd_set_ctrlmode { 218 u8 mode; 219 u8 reserved[27]; 220 } __packed; 221 222 struct kvaser_err_frame_data { 223 u8 bus_status; 224 u8 reserved0; 225 u8 tx_err_counter; 226 u8 rx_err_counter; 227 u8 reserved1[4]; 228 } __packed; 229 230 struct kvaser_cmd_rx_can { 231 u8 cmd_len; 232 u8 cmd_no; 233 u8 channel; 234 u8 flags; 235 __le16 timestamp[3]; 236 u8 dlc; 237 u8 padding; 238 __le32 id; 239 union { 240 u8 data[8]; 241 struct kvaser_err_frame_data err_frame_data; 242 }; 243 } __packed; 244 245 /* Extended CAN ID flag. Used in rx_can and tx_can */ 246 #define KVASER_USB_HYDRA_EXTENDED_FRAME_ID BIT(31) 247 struct kvaser_cmd_tx_can { 248 __le32 id; 249 u8 data[8]; 250 u8 dlc; 251 u8 flags; 252 __le16 transid; 253 u8 channel; 254 u8 reserved[11]; 255 } __packed; 256 257 struct kvaser_cmd_header { 258 u8 cmd_no; 259 /* The destination HE address is stored in 0..5 of he_addr. 260 * The upper part of source HE address is stored in 6..7 of he_addr, and 261 * the lower part is stored in 12..15 of transid. 262 */ 263 u8 he_addr; 264 __le16 transid; 265 } __packed; 266 267 struct kvaser_cmd { 268 struct kvaser_cmd_header header; 269 union { 270 struct kvaser_cmd_map_ch_req map_ch_req; 271 struct kvaser_cmd_map_ch_res map_ch_res; 272 273 struct kvaser_cmd_card_info card_info; 274 struct kvaser_cmd_sw_info sw_info; 275 struct kvaser_cmd_sw_detail_req sw_detail_req; 276 struct kvaser_cmd_sw_detail_res sw_detail_res; 277 278 struct kvaser_cmd_cap_req cap_req; 279 struct kvaser_cmd_cap_res cap_res; 280 281 struct kvaser_cmd_error_event error_event; 282 283 struct kvaser_cmd_set_busparams set_busparams_req; 284 285 struct kvaser_cmd_chip_state_event chip_state_event; 286 287 struct kvaser_cmd_set_ctrlmode set_ctrlmode; 288 289 struct kvaser_cmd_rx_can rx_can; 290 struct kvaser_cmd_tx_can tx_can; 291 } __packed; 292 } __packed; 293 294 /* CAN frame flags. Used in rx_can, ext_rx_can, tx_can and ext_tx_can */ 295 #define KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME BIT(0) 296 #define KVASER_USB_HYDRA_CF_FLAG_OVERRUN BIT(1) 297 #define KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME BIT(4) 298 #define KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID BIT(5) 299 /* CAN frame flags. Used in ext_rx_can and ext_tx_can */ 300 #define KVASER_USB_HYDRA_CF_FLAG_OSM_NACK BIT(12) 301 #define KVASER_USB_HYDRA_CF_FLAG_ABL BIT(13) 302 #define KVASER_USB_HYDRA_CF_FLAG_FDF BIT(16) 303 #define KVASER_USB_HYDRA_CF_FLAG_BRS BIT(17) 304 #define KVASER_USB_HYDRA_CF_FLAG_ESI BIT(18) 305 306 /* KCAN packet header macros. Used in ext_rx_can and ext_tx_can */ 307 #define KVASER_USB_KCAN_DATA_DLC_BITS 4 308 #define KVASER_USB_KCAN_DATA_DLC_SHIFT 8 309 #define KVASER_USB_KCAN_DATA_DLC_MASK \ 310 GENMASK(KVASER_USB_KCAN_DATA_DLC_BITS - 1 + \ 311 KVASER_USB_KCAN_DATA_DLC_SHIFT, \ 312 KVASER_USB_KCAN_DATA_DLC_SHIFT) 313 314 #define KVASER_USB_KCAN_DATA_BRS BIT(14) 315 #define KVASER_USB_KCAN_DATA_FDF BIT(15) 316 #define KVASER_USB_KCAN_DATA_OSM BIT(16) 317 #define KVASER_USB_KCAN_DATA_AREQ BIT(31) 318 #define KVASER_USB_KCAN_DATA_SRR BIT(31) 319 #define KVASER_USB_KCAN_DATA_RTR BIT(29) 320 #define KVASER_USB_KCAN_DATA_IDE BIT(30) 321 struct kvaser_cmd_ext_rx_can { 322 __le32 flags; 323 __le32 id; 324 __le32 kcan_id; 325 __le32 kcan_header; 326 __le64 timestamp; 327 union { 328 u8 kcan_payload[64]; 329 struct kvaser_err_frame_data err_frame_data; 330 }; 331 } __packed; 332 333 struct kvaser_cmd_ext_tx_can { 334 __le32 flags; 335 __le32 id; 336 __le32 kcan_id; 337 __le32 kcan_header; 338 u8 databytes; 339 u8 dlc; 340 u8 reserved[6]; 341 u8 kcan_payload[64]; 342 } __packed; 343 344 struct kvaser_cmd_ext_tx_ack { 345 __le32 flags; 346 u8 reserved0[4]; 347 __le64 timestamp; 348 u8 reserved1[8]; 349 } __packed; 350 351 /* struct for extended commands (CMD_EXTENDED) */ 352 struct kvaser_cmd_ext { 353 struct kvaser_cmd_header header; 354 __le16 len; 355 u8 cmd_no_ext; 356 u8 reserved; 357 358 union { 359 struct kvaser_cmd_ext_rx_can rx_can; 360 struct kvaser_cmd_ext_tx_can tx_can; 361 struct kvaser_cmd_ext_tx_ack tx_ack; 362 } __packed; 363 } __packed; 364 365 static const struct can_bittiming_const kvaser_usb_hydra_kcan_bittiming_c = { 366 .name = "kvaser_usb_kcan", 367 .tseg1_min = 1, 368 .tseg1_max = 255, 369 .tseg2_min = 1, 370 .tseg2_max = 32, 371 .sjw_max = 16, 372 .brp_min = 1, 373 .brp_max = 8192, 374 .brp_inc = 1, 375 }; 376 377 static const struct can_bittiming_const kvaser_usb_hydra_flexc_bittiming_c = { 378 .name = "kvaser_usb_flex", 379 .tseg1_min = 4, 380 .tseg1_max = 16, 381 .tseg2_min = 2, 382 .tseg2_max = 8, 383 .sjw_max = 4, 384 .brp_min = 1, 385 .brp_max = 256, 386 .brp_inc = 1, 387 }; 388 389 static const struct can_bittiming_const kvaser_usb_hydra_rt_bittiming_c = { 390 .name = "kvaser_usb_rt", 391 .tseg1_min = 2, 392 .tseg1_max = 96, 393 .tseg2_min = 2, 394 .tseg2_max = 32, 395 .sjw_max = 32, 396 .brp_min = 1, 397 .brp_max = 1024, 398 .brp_inc = 1, 399 }; 400 401 static const struct can_bittiming_const kvaser_usb_hydra_rtd_bittiming_c = { 402 .name = "kvaser_usb_rt", 403 .tseg1_min = 2, 404 .tseg1_max = 39, 405 .tseg2_min = 2, 406 .tseg2_max = 8, 407 .sjw_max = 8, 408 .brp_min = 1, 409 .brp_max = 1024, 410 .brp_inc = 1, 411 }; 412 413 #define KVASER_USB_HYDRA_TRANSID_BITS 12 414 #define KVASER_USB_HYDRA_TRANSID_MASK \ 415 GENMASK(KVASER_USB_HYDRA_TRANSID_BITS - 1, 0) 416 #define KVASER_USB_HYDRA_HE_ADDR_SRC_MASK GENMASK(7, 6) 417 #define KVASER_USB_HYDRA_HE_ADDR_DEST_MASK GENMASK(5, 0) 418 #define KVASER_USB_HYDRA_HE_ADDR_SRC_BITS 2 419 static inline u16 kvaser_usb_hydra_get_cmd_transid(const struct kvaser_cmd *cmd) 420 { 421 return le16_to_cpu(cmd->header.transid) & KVASER_USB_HYDRA_TRANSID_MASK; 422 } 423 424 static inline void kvaser_usb_hydra_set_cmd_transid(struct kvaser_cmd *cmd, 425 u16 transid) 426 { 427 cmd->header.transid = 428 cpu_to_le16(transid & KVASER_USB_HYDRA_TRANSID_MASK); 429 } 430 431 static inline u8 kvaser_usb_hydra_get_cmd_src_he(const struct kvaser_cmd *cmd) 432 { 433 return (cmd->header.he_addr & KVASER_USB_HYDRA_HE_ADDR_SRC_MASK) >> 434 KVASER_USB_HYDRA_HE_ADDR_SRC_BITS | 435 le16_to_cpu(cmd->header.transid) >> 436 KVASER_USB_HYDRA_TRANSID_BITS; 437 } 438 439 static inline void kvaser_usb_hydra_set_cmd_dest_he(struct kvaser_cmd *cmd, 440 u8 dest_he) 441 { 442 cmd->header.he_addr = 443 (cmd->header.he_addr & KVASER_USB_HYDRA_HE_ADDR_SRC_MASK) | 444 (dest_he & KVASER_USB_HYDRA_HE_ADDR_DEST_MASK); 445 } 446 447 static u8 kvaser_usb_hydra_channel_from_cmd(const struct kvaser_usb *dev, 448 const struct kvaser_cmd *cmd) 449 { 450 int i; 451 u8 channel = 0xff; 452 u8 src_he = kvaser_usb_hydra_get_cmd_src_he(cmd); 453 454 for (i = 0; i < KVASER_USB_MAX_NET_DEVICES; i++) { 455 if (dev->card_data.hydra.channel_to_he[i] == src_he) { 456 channel = i; 457 break; 458 } 459 } 460 461 return channel; 462 } 463 464 static u16 kvaser_usb_hydra_get_next_transid(struct kvaser_usb *dev) 465 { 466 unsigned long flags; 467 u16 transid; 468 struct kvaser_usb_dev_card_data_hydra *card_data = 469 &dev->card_data.hydra; 470 471 spin_lock_irqsave(&card_data->transid_lock, flags); 472 transid = card_data->transid; 473 if (transid >= KVASER_USB_HYDRA_MAX_TRANSID) 474 transid = KVASER_USB_HYDRA_MIN_TRANSID; 475 else 476 transid++; 477 card_data->transid = transid; 478 spin_unlock_irqrestore(&card_data->transid_lock, flags); 479 480 return transid; 481 } 482 483 static size_t kvaser_usb_hydra_cmd_size(struct kvaser_cmd *cmd) 484 { 485 size_t ret; 486 487 if (cmd->header.cmd_no == CMD_EXTENDED) 488 ret = le16_to_cpu(((struct kvaser_cmd_ext *)cmd)->len); 489 else 490 ret = sizeof(struct kvaser_cmd); 491 492 return ret; 493 } 494 495 static struct kvaser_usb_net_priv * 496 kvaser_usb_hydra_net_priv_from_cmd(const struct kvaser_usb *dev, 497 const struct kvaser_cmd *cmd) 498 { 499 struct kvaser_usb_net_priv *priv = NULL; 500 u8 channel = kvaser_usb_hydra_channel_from_cmd(dev, cmd); 501 502 if (channel >= dev->nchannels) 503 dev_err(&dev->intf->dev, 504 "Invalid channel number (%d)\n", channel); 505 else 506 priv = dev->nets[channel]; 507 508 return priv; 509 } 510 511 static ktime_t 512 kvaser_usb_hydra_ktime_from_rx_cmd(const struct kvaser_usb_dev_cfg *cfg, 513 const struct kvaser_cmd *cmd) 514 { 515 u64 ticks; 516 517 if (cmd->header.cmd_no == CMD_EXTENDED) { 518 struct kvaser_cmd_ext *cmd_ext = (struct kvaser_cmd_ext *)cmd; 519 520 ticks = le64_to_cpu(cmd_ext->rx_can.timestamp); 521 } else { 522 ticks = le16_to_cpu(cmd->rx_can.timestamp[0]); 523 ticks += (u64)(le16_to_cpu(cmd->rx_can.timestamp[1])) << 16; 524 ticks += (u64)(le16_to_cpu(cmd->rx_can.timestamp[2])) << 32; 525 } 526 527 return ns_to_ktime(div_u64(ticks * 1000, cfg->timestamp_freq)); 528 } 529 530 static int kvaser_usb_hydra_send_simple_cmd(struct kvaser_usb *dev, 531 u8 cmd_no, int channel) 532 { 533 struct kvaser_cmd *cmd; 534 int err; 535 536 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 537 if (!cmd) 538 return -ENOMEM; 539 540 cmd->header.cmd_no = cmd_no; 541 if (channel < 0) { 542 kvaser_usb_hydra_set_cmd_dest_he 543 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL); 544 } else { 545 if (channel >= KVASER_USB_MAX_NET_DEVICES) { 546 dev_err(&dev->intf->dev, "channel (%d) out of range.\n", 547 channel); 548 err = -EINVAL; 549 goto end; 550 } 551 kvaser_usb_hydra_set_cmd_dest_he 552 (cmd, dev->card_data.hydra.channel_to_he[channel]); 553 } 554 kvaser_usb_hydra_set_cmd_transid 555 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 556 557 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 558 if (err) 559 goto end; 560 561 end: 562 kfree(cmd); 563 564 return err; 565 } 566 567 static int 568 kvaser_usb_hydra_send_simple_cmd_async(struct kvaser_usb_net_priv *priv, 569 u8 cmd_no) 570 { 571 struct kvaser_cmd *cmd; 572 struct kvaser_usb *dev = priv->dev; 573 int err; 574 575 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_ATOMIC); 576 if (!cmd) 577 return -ENOMEM; 578 579 cmd->header.cmd_no = cmd_no; 580 581 kvaser_usb_hydra_set_cmd_dest_he 582 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]); 583 kvaser_usb_hydra_set_cmd_transid 584 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 585 586 err = kvaser_usb_send_cmd_async(priv, cmd, 587 kvaser_usb_hydra_cmd_size(cmd)); 588 if (err) 589 kfree(cmd); 590 591 return err; 592 } 593 594 /* This function is used for synchronously waiting on hydra control commands. 595 * Note: Compared to kvaser_usb_hydra_read_bulk_callback(), we never need to 596 * handle partial hydra commands. Since hydra control commands are always 597 * non-extended commands. 598 */ 599 static int kvaser_usb_hydra_wait_cmd(const struct kvaser_usb *dev, u8 cmd_no, 600 struct kvaser_cmd *cmd) 601 { 602 void *buf; 603 int err; 604 unsigned long timeout = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT); 605 606 if (cmd->header.cmd_no == CMD_EXTENDED) { 607 dev_err(&dev->intf->dev, "Wait for CMD_EXTENDED not allowed\n"); 608 return -EINVAL; 609 } 610 611 buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL); 612 if (!buf) 613 return -ENOMEM; 614 615 do { 616 int actual_len = 0; 617 int pos = 0; 618 619 err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE, 620 &actual_len); 621 if (err < 0) 622 goto end; 623 624 while (pos < actual_len) { 625 struct kvaser_cmd *tmp_cmd; 626 size_t cmd_len; 627 628 tmp_cmd = buf + pos; 629 cmd_len = kvaser_usb_hydra_cmd_size(tmp_cmd); 630 if (pos + cmd_len > actual_len) { 631 dev_err_ratelimited(&dev->intf->dev, 632 "Format error\n"); 633 break; 634 } 635 636 if (tmp_cmd->header.cmd_no == cmd_no) { 637 memcpy(cmd, tmp_cmd, cmd_len); 638 goto end; 639 } 640 pos += cmd_len; 641 } 642 } while (time_before(jiffies, timeout)); 643 644 err = -EINVAL; 645 646 end: 647 kfree(buf); 648 649 return err; 650 } 651 652 static int kvaser_usb_hydra_map_channel_resp(struct kvaser_usb *dev, 653 const struct kvaser_cmd *cmd) 654 { 655 u8 he, channel; 656 u16 transid = kvaser_usb_hydra_get_cmd_transid(cmd); 657 struct kvaser_usb_dev_card_data_hydra *card_data = 658 &dev->card_data.hydra; 659 660 if (transid > 0x007f || transid < 0x0040) { 661 dev_err(&dev->intf->dev, 662 "CMD_MAP_CHANNEL_RESP, invalid transid: 0x%x\n", 663 transid); 664 return -EINVAL; 665 } 666 667 switch (transid) { 668 case KVASER_USB_HYDRA_TRANSID_CANHE: 669 case KVASER_USB_HYDRA_TRANSID_CANHE + 1: 670 case KVASER_USB_HYDRA_TRANSID_CANHE + 2: 671 case KVASER_USB_HYDRA_TRANSID_CANHE + 3: 672 case KVASER_USB_HYDRA_TRANSID_CANHE + 4: 673 channel = transid & 0x000f; 674 he = cmd->map_ch_res.he_addr; 675 card_data->channel_to_he[channel] = he; 676 break; 677 case KVASER_USB_HYDRA_TRANSID_SYSDBG: 678 card_data->sysdbg_he = cmd->map_ch_res.he_addr; 679 break; 680 default: 681 dev_warn(&dev->intf->dev, 682 "Unknown CMD_MAP_CHANNEL_RESP transid=0x%x\n", 683 transid); 684 break; 685 } 686 687 return 0; 688 } 689 690 static int kvaser_usb_hydra_map_channel(struct kvaser_usb *dev, u16 transid, 691 u8 channel, const char *name) 692 { 693 struct kvaser_cmd *cmd; 694 int err; 695 696 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 697 if (!cmd) 698 return -ENOMEM; 699 700 strcpy(cmd->map_ch_req.name, name); 701 cmd->header.cmd_no = CMD_MAP_CHANNEL_REQ; 702 kvaser_usb_hydra_set_cmd_dest_he 703 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ROUTER); 704 cmd->map_ch_req.channel = channel; 705 706 kvaser_usb_hydra_set_cmd_transid(cmd, transid); 707 708 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 709 if (err) 710 goto end; 711 712 err = kvaser_usb_hydra_wait_cmd(dev, CMD_MAP_CHANNEL_RESP, cmd); 713 if (err) 714 goto end; 715 716 err = kvaser_usb_hydra_map_channel_resp(dev, cmd); 717 if (err) 718 goto end; 719 720 end: 721 kfree(cmd); 722 723 return err; 724 } 725 726 static int kvaser_usb_hydra_get_single_capability(struct kvaser_usb *dev, 727 u16 cap_cmd_req, u16 *status) 728 { 729 struct kvaser_usb_dev_card_data *card_data = &dev->card_data; 730 struct kvaser_cmd *cmd; 731 u32 value = 0; 732 u32 mask = 0; 733 u16 cap_cmd_res; 734 int err; 735 int i; 736 737 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 738 if (!cmd) 739 return -ENOMEM; 740 741 cmd->header.cmd_no = CMD_GET_CAPABILITIES_REQ; 742 cmd->cap_req.cap_cmd = cpu_to_le16(cap_cmd_req); 743 744 kvaser_usb_hydra_set_cmd_dest_he(cmd, card_data->hydra.sysdbg_he); 745 kvaser_usb_hydra_set_cmd_transid 746 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 747 748 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 749 if (err) 750 goto end; 751 752 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_CAPABILITIES_RESP, cmd); 753 if (err) 754 goto end; 755 756 *status = le16_to_cpu(cmd->cap_res.status); 757 758 if (*status != KVASER_USB_HYDRA_CAP_STAT_OK) 759 goto end; 760 761 cap_cmd_res = le16_to_cpu(cmd->cap_res.cap_cmd); 762 switch (cap_cmd_res) { 763 case KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE: 764 case KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT: 765 case KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT: 766 value = le32_to_cpu(cmd->cap_res.value); 767 mask = le32_to_cpu(cmd->cap_res.mask); 768 break; 769 default: 770 dev_warn(&dev->intf->dev, "Unknown capability command %u\n", 771 cap_cmd_res); 772 break; 773 } 774 775 for (i = 0; i < dev->nchannels; i++) { 776 if (BIT(i) & (value & mask)) { 777 switch (cap_cmd_res) { 778 case KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE: 779 card_data->ctrlmode_supported |= 780 CAN_CTRLMODE_LISTENONLY; 781 break; 782 case KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT: 783 card_data->capabilities |= 784 KVASER_USB_CAP_BERR_CAP; 785 break; 786 case KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT: 787 card_data->ctrlmode_supported |= 788 CAN_CTRLMODE_ONE_SHOT; 789 break; 790 } 791 } 792 } 793 794 end: 795 kfree(cmd); 796 797 return err; 798 } 799 800 static void kvaser_usb_hydra_start_chip_reply(const struct kvaser_usb *dev, 801 const struct kvaser_cmd *cmd) 802 { 803 struct kvaser_usb_net_priv *priv; 804 805 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd); 806 if (!priv) 807 return; 808 809 if (completion_done(&priv->start_comp) && 810 netif_queue_stopped(priv->netdev)) { 811 netif_wake_queue(priv->netdev); 812 } else { 813 netif_start_queue(priv->netdev); 814 complete(&priv->start_comp); 815 } 816 } 817 818 static void kvaser_usb_hydra_stop_chip_reply(const struct kvaser_usb *dev, 819 const struct kvaser_cmd *cmd) 820 { 821 struct kvaser_usb_net_priv *priv; 822 823 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd); 824 if (!priv) 825 return; 826 827 complete(&priv->stop_comp); 828 } 829 830 static void kvaser_usb_hydra_flush_queue_reply(const struct kvaser_usb *dev, 831 const struct kvaser_cmd *cmd) 832 { 833 struct kvaser_usb_net_priv *priv; 834 835 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd); 836 if (!priv) 837 return; 838 839 complete(&priv->flush_comp); 840 } 841 842 static void 843 kvaser_usb_hydra_bus_status_to_can_state(const struct kvaser_usb_net_priv *priv, 844 u8 bus_status, 845 const struct can_berr_counter *bec, 846 enum can_state *new_state) 847 { 848 if (bus_status & KVASER_USB_HYDRA_BUS_BUS_OFF) { 849 *new_state = CAN_STATE_BUS_OFF; 850 } else if (bus_status & KVASER_USB_HYDRA_BUS_ERR_PASS) { 851 *new_state = CAN_STATE_ERROR_PASSIVE; 852 } else if (bus_status == KVASER_USB_HYDRA_BUS_ERR_ACT) { 853 if (bec->txerr >= 128 || bec->rxerr >= 128) { 854 netdev_warn(priv->netdev, 855 "ERR_ACTIVE but err tx=%u or rx=%u >=128\n", 856 bec->txerr, bec->rxerr); 857 *new_state = CAN_STATE_ERROR_PASSIVE; 858 } else if (bec->txerr >= 96 || bec->rxerr >= 96) { 859 *new_state = CAN_STATE_ERROR_WARNING; 860 } else { 861 *new_state = CAN_STATE_ERROR_ACTIVE; 862 } 863 } 864 } 865 866 static void kvaser_usb_hydra_update_state(struct kvaser_usb_net_priv *priv, 867 u8 bus_status, 868 const struct can_berr_counter *bec) 869 { 870 struct net_device *netdev = priv->netdev; 871 struct can_frame *cf; 872 struct sk_buff *skb; 873 enum can_state new_state, old_state; 874 875 old_state = priv->can.state; 876 877 kvaser_usb_hydra_bus_status_to_can_state(priv, bus_status, bec, 878 &new_state); 879 880 if (new_state == old_state) 881 return; 882 883 /* Ignore state change if previous state was STOPPED and the new state 884 * is BUS_OFF. Firmware always report this as BUS_OFF, since firmware 885 * does not distinguish between BUS_OFF and STOPPED. 886 */ 887 if (old_state == CAN_STATE_STOPPED && new_state == CAN_STATE_BUS_OFF) 888 return; 889 890 skb = alloc_can_err_skb(netdev, &cf); 891 if (skb) { 892 enum can_state tx_state, rx_state; 893 894 tx_state = (bec->txerr >= bec->rxerr) ? 895 new_state : CAN_STATE_ERROR_ACTIVE; 896 rx_state = (bec->txerr <= bec->rxerr) ? 897 new_state : CAN_STATE_ERROR_ACTIVE; 898 can_change_state(netdev, cf, tx_state, rx_state); 899 } 900 901 if (new_state == CAN_STATE_BUS_OFF && old_state < CAN_STATE_BUS_OFF) { 902 if (!priv->can.restart_ms) 903 kvaser_usb_hydra_send_simple_cmd_async 904 (priv, CMD_STOP_CHIP_REQ); 905 906 can_bus_off(netdev); 907 } 908 909 if (!skb) { 910 netdev_warn(netdev, "No memory left for err_skb\n"); 911 return; 912 } 913 914 if (priv->can.restart_ms && 915 old_state >= CAN_STATE_BUS_OFF && 916 new_state < CAN_STATE_BUS_OFF) 917 priv->can.can_stats.restarts++; 918 919 cf->data[6] = bec->txerr; 920 cf->data[7] = bec->rxerr; 921 922 netif_rx(skb); 923 } 924 925 static void kvaser_usb_hydra_state_event(const struct kvaser_usb *dev, 926 const struct kvaser_cmd *cmd) 927 { 928 struct kvaser_usb_net_priv *priv; 929 struct can_berr_counter bec; 930 u8 bus_status; 931 932 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd); 933 if (!priv) 934 return; 935 936 bus_status = cmd->chip_state_event.bus_status; 937 bec.txerr = cmd->chip_state_event.tx_err_counter; 938 bec.rxerr = cmd->chip_state_event.rx_err_counter; 939 940 kvaser_usb_hydra_update_state(priv, bus_status, &bec); 941 priv->bec.txerr = bec.txerr; 942 priv->bec.rxerr = bec.rxerr; 943 } 944 945 static void kvaser_usb_hydra_error_event_parameter(const struct kvaser_usb *dev, 946 const struct kvaser_cmd *cmd) 947 { 948 /* info1 will contain the offending cmd_no */ 949 switch (le16_to_cpu(cmd->error_event.info1)) { 950 case CMD_START_CHIP_REQ: 951 dev_warn(&dev->intf->dev, 952 "CMD_START_CHIP_REQ error in parameter\n"); 953 break; 954 955 case CMD_STOP_CHIP_REQ: 956 dev_warn(&dev->intf->dev, 957 "CMD_STOP_CHIP_REQ error in parameter\n"); 958 break; 959 960 case CMD_FLUSH_QUEUE: 961 dev_warn(&dev->intf->dev, 962 "CMD_FLUSH_QUEUE error in parameter\n"); 963 break; 964 965 case CMD_SET_BUSPARAMS_REQ: 966 dev_warn(&dev->intf->dev, 967 "Set bittiming failed. Error in parameter\n"); 968 break; 969 970 case CMD_SET_BUSPARAMS_FD_REQ: 971 dev_warn(&dev->intf->dev, 972 "Set data bittiming failed. Error in parameter\n"); 973 break; 974 975 default: 976 dev_warn(&dev->intf->dev, 977 "Unhandled parameter error event cmd_no (%u)\n", 978 le16_to_cpu(cmd->error_event.info1)); 979 break; 980 } 981 } 982 983 static void kvaser_usb_hydra_error_event(const struct kvaser_usb *dev, 984 const struct kvaser_cmd *cmd) 985 { 986 switch (cmd->error_event.error_code) { 987 case KVASER_USB_HYDRA_ERROR_EVENT_PARAM: 988 kvaser_usb_hydra_error_event_parameter(dev, cmd); 989 break; 990 991 case KVASER_USB_HYDRA_ERROR_EVENT_CAN: 992 /* Wrong channel mapping?! This should never happen! 993 * info1 will contain the offending cmd_no 994 */ 995 dev_err(&dev->intf->dev, 996 "Received CAN error event for cmd_no (%u)\n", 997 le16_to_cpu(cmd->error_event.info1)); 998 break; 999 1000 default: 1001 dev_warn(&dev->intf->dev, 1002 "Unhandled error event (%d)\n", 1003 cmd->error_event.error_code); 1004 break; 1005 } 1006 } 1007 1008 static void 1009 kvaser_usb_hydra_error_frame(struct kvaser_usb_net_priv *priv, 1010 const struct kvaser_err_frame_data *err_frame_data, 1011 ktime_t hwtstamp) 1012 { 1013 struct net_device *netdev = priv->netdev; 1014 struct net_device_stats *stats = &netdev->stats; 1015 struct can_frame *cf; 1016 struct sk_buff *skb; 1017 struct skb_shared_hwtstamps *shhwtstamps; 1018 struct can_berr_counter bec; 1019 enum can_state new_state, old_state; 1020 u8 bus_status; 1021 1022 priv->can.can_stats.bus_error++; 1023 stats->rx_errors++; 1024 1025 bus_status = err_frame_data->bus_status; 1026 bec.txerr = err_frame_data->tx_err_counter; 1027 bec.rxerr = err_frame_data->rx_err_counter; 1028 1029 old_state = priv->can.state; 1030 kvaser_usb_hydra_bus_status_to_can_state(priv, bus_status, &bec, 1031 &new_state); 1032 1033 skb = alloc_can_err_skb(netdev, &cf); 1034 1035 if (new_state != old_state) { 1036 if (skb) { 1037 enum can_state tx_state, rx_state; 1038 1039 tx_state = (bec.txerr >= bec.rxerr) ? 1040 new_state : CAN_STATE_ERROR_ACTIVE; 1041 rx_state = (bec.txerr <= bec.rxerr) ? 1042 new_state : CAN_STATE_ERROR_ACTIVE; 1043 1044 can_change_state(netdev, cf, tx_state, rx_state); 1045 1046 if (priv->can.restart_ms && 1047 old_state >= CAN_STATE_BUS_OFF && 1048 new_state < CAN_STATE_BUS_OFF) 1049 cf->can_id |= CAN_ERR_RESTARTED; 1050 } 1051 1052 if (new_state == CAN_STATE_BUS_OFF) { 1053 if (!priv->can.restart_ms) 1054 kvaser_usb_hydra_send_simple_cmd_async 1055 (priv, CMD_STOP_CHIP_REQ); 1056 1057 can_bus_off(netdev); 1058 } 1059 } 1060 1061 if (!skb) { 1062 stats->rx_dropped++; 1063 netdev_warn(netdev, "No memory left for err_skb\n"); 1064 return; 1065 } 1066 1067 shhwtstamps = skb_hwtstamps(skb); 1068 shhwtstamps->hwtstamp = hwtstamp; 1069 1070 cf->can_id |= CAN_ERR_BUSERROR; 1071 cf->data[6] = bec.txerr; 1072 cf->data[7] = bec.rxerr; 1073 1074 netif_rx(skb); 1075 1076 priv->bec.txerr = bec.txerr; 1077 priv->bec.rxerr = bec.rxerr; 1078 } 1079 1080 static void kvaser_usb_hydra_one_shot_fail(struct kvaser_usb_net_priv *priv, 1081 const struct kvaser_cmd_ext *cmd) 1082 { 1083 struct net_device *netdev = priv->netdev; 1084 struct net_device_stats *stats = &netdev->stats; 1085 struct can_frame *cf; 1086 struct sk_buff *skb; 1087 u32 flags; 1088 1089 skb = alloc_can_err_skb(netdev, &cf); 1090 if (!skb) { 1091 stats->rx_dropped++; 1092 netdev_warn(netdev, "No memory left for err_skb\n"); 1093 return; 1094 } 1095 1096 cf->can_id |= CAN_ERR_BUSERROR; 1097 flags = le32_to_cpu(cmd->tx_ack.flags); 1098 1099 if (flags & KVASER_USB_HYDRA_CF_FLAG_OSM_NACK) 1100 cf->can_id |= CAN_ERR_ACK; 1101 if (flags & KVASER_USB_HYDRA_CF_FLAG_ABL) { 1102 cf->can_id |= CAN_ERR_LOSTARB; 1103 priv->can.can_stats.arbitration_lost++; 1104 } 1105 1106 stats->tx_errors++; 1107 netif_rx(skb); 1108 } 1109 1110 static void kvaser_usb_hydra_tx_acknowledge(const struct kvaser_usb *dev, 1111 const struct kvaser_cmd *cmd) 1112 { 1113 struct kvaser_usb_tx_urb_context *context; 1114 struct kvaser_usb_net_priv *priv; 1115 unsigned long irq_flags; 1116 bool one_shot_fail = false; 1117 u16 transid = kvaser_usb_hydra_get_cmd_transid(cmd); 1118 1119 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd); 1120 if (!priv) 1121 return; 1122 1123 if (!netif_device_present(priv->netdev)) 1124 return; 1125 1126 if (cmd->header.cmd_no == CMD_EXTENDED) { 1127 struct kvaser_cmd_ext *cmd_ext = (struct kvaser_cmd_ext *)cmd; 1128 u32 flags = le32_to_cpu(cmd_ext->tx_ack.flags); 1129 1130 if (flags & (KVASER_USB_HYDRA_CF_FLAG_OSM_NACK | 1131 KVASER_USB_HYDRA_CF_FLAG_ABL)) { 1132 kvaser_usb_hydra_one_shot_fail(priv, cmd_ext); 1133 one_shot_fail = true; 1134 } 1135 } 1136 1137 context = &priv->tx_contexts[transid % dev->max_tx_urbs]; 1138 if (!one_shot_fail) { 1139 struct net_device_stats *stats = &priv->netdev->stats; 1140 1141 stats->tx_packets++; 1142 stats->tx_bytes += can_fd_dlc2len(context->dlc); 1143 } 1144 1145 spin_lock_irqsave(&priv->tx_contexts_lock, irq_flags); 1146 1147 can_get_echo_skb(priv->netdev, context->echo_index, NULL); 1148 context->echo_index = dev->max_tx_urbs; 1149 --priv->active_tx_contexts; 1150 netif_wake_queue(priv->netdev); 1151 1152 spin_unlock_irqrestore(&priv->tx_contexts_lock, irq_flags); 1153 } 1154 1155 static void kvaser_usb_hydra_rx_msg_std(const struct kvaser_usb *dev, 1156 const struct kvaser_cmd *cmd) 1157 { 1158 struct kvaser_usb_net_priv *priv = NULL; 1159 struct can_frame *cf; 1160 struct sk_buff *skb; 1161 struct skb_shared_hwtstamps *shhwtstamps; 1162 struct net_device_stats *stats; 1163 u8 flags; 1164 ktime_t hwtstamp; 1165 1166 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd); 1167 if (!priv) 1168 return; 1169 1170 stats = &priv->netdev->stats; 1171 1172 flags = cmd->rx_can.flags; 1173 hwtstamp = kvaser_usb_hydra_ktime_from_rx_cmd(dev->cfg, cmd); 1174 1175 if (flags & KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME) { 1176 kvaser_usb_hydra_error_frame(priv, &cmd->rx_can.err_frame_data, 1177 hwtstamp); 1178 return; 1179 } 1180 1181 skb = alloc_can_skb(priv->netdev, &cf); 1182 if (!skb) { 1183 stats->rx_dropped++; 1184 return; 1185 } 1186 1187 shhwtstamps = skb_hwtstamps(skb); 1188 shhwtstamps->hwtstamp = hwtstamp; 1189 1190 cf->can_id = le32_to_cpu(cmd->rx_can.id); 1191 1192 if (cf->can_id & KVASER_USB_HYDRA_EXTENDED_FRAME_ID) { 1193 cf->can_id &= CAN_EFF_MASK; 1194 cf->can_id |= CAN_EFF_FLAG; 1195 } else { 1196 cf->can_id &= CAN_SFF_MASK; 1197 } 1198 1199 if (flags & KVASER_USB_HYDRA_CF_FLAG_OVERRUN) 1200 kvaser_usb_can_rx_over_error(priv->netdev); 1201 1202 cf->len = can_cc_dlc2len(cmd->rx_can.dlc); 1203 1204 if (flags & KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME) 1205 cf->can_id |= CAN_RTR_FLAG; 1206 else 1207 memcpy(cf->data, cmd->rx_can.data, cf->len); 1208 1209 stats->rx_packets++; 1210 stats->rx_bytes += cf->len; 1211 netif_rx(skb); 1212 } 1213 1214 static void kvaser_usb_hydra_rx_msg_ext(const struct kvaser_usb *dev, 1215 const struct kvaser_cmd_ext *cmd) 1216 { 1217 struct kvaser_cmd *std_cmd = (struct kvaser_cmd *)cmd; 1218 struct kvaser_usb_net_priv *priv; 1219 struct canfd_frame *cf; 1220 struct sk_buff *skb; 1221 struct skb_shared_hwtstamps *shhwtstamps; 1222 struct net_device_stats *stats; 1223 u32 flags; 1224 u8 dlc; 1225 u32 kcan_header; 1226 ktime_t hwtstamp; 1227 1228 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, std_cmd); 1229 if (!priv) 1230 return; 1231 1232 stats = &priv->netdev->stats; 1233 1234 kcan_header = le32_to_cpu(cmd->rx_can.kcan_header); 1235 dlc = (kcan_header & KVASER_USB_KCAN_DATA_DLC_MASK) >> 1236 KVASER_USB_KCAN_DATA_DLC_SHIFT; 1237 1238 flags = le32_to_cpu(cmd->rx_can.flags); 1239 hwtstamp = kvaser_usb_hydra_ktime_from_rx_cmd(dev->cfg, std_cmd); 1240 1241 if (flags & KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME) { 1242 kvaser_usb_hydra_error_frame(priv, &cmd->rx_can.err_frame_data, 1243 hwtstamp); 1244 return; 1245 } 1246 1247 if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF) 1248 skb = alloc_canfd_skb(priv->netdev, &cf); 1249 else 1250 skb = alloc_can_skb(priv->netdev, (struct can_frame **)&cf); 1251 1252 if (!skb) { 1253 stats->rx_dropped++; 1254 return; 1255 } 1256 1257 shhwtstamps = skb_hwtstamps(skb); 1258 shhwtstamps->hwtstamp = hwtstamp; 1259 1260 cf->can_id = le32_to_cpu(cmd->rx_can.id); 1261 1262 if (flags & KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID) { 1263 cf->can_id &= CAN_EFF_MASK; 1264 cf->can_id |= CAN_EFF_FLAG; 1265 } else { 1266 cf->can_id &= CAN_SFF_MASK; 1267 } 1268 1269 if (flags & KVASER_USB_HYDRA_CF_FLAG_OVERRUN) 1270 kvaser_usb_can_rx_over_error(priv->netdev); 1271 1272 if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF) { 1273 cf->len = can_fd_dlc2len(dlc); 1274 if (flags & KVASER_USB_HYDRA_CF_FLAG_BRS) 1275 cf->flags |= CANFD_BRS; 1276 if (flags & KVASER_USB_HYDRA_CF_FLAG_ESI) 1277 cf->flags |= CANFD_ESI; 1278 } else { 1279 cf->len = can_cc_dlc2len(dlc); 1280 } 1281 1282 if (flags & KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME) 1283 cf->can_id |= CAN_RTR_FLAG; 1284 else 1285 memcpy(cf->data, cmd->rx_can.kcan_payload, cf->len); 1286 1287 stats->rx_packets++; 1288 stats->rx_bytes += cf->len; 1289 netif_rx(skb); 1290 } 1291 1292 static void kvaser_usb_hydra_handle_cmd_std(const struct kvaser_usb *dev, 1293 const struct kvaser_cmd *cmd) 1294 { 1295 switch (cmd->header.cmd_no) { 1296 case CMD_START_CHIP_RESP: 1297 kvaser_usb_hydra_start_chip_reply(dev, cmd); 1298 break; 1299 1300 case CMD_STOP_CHIP_RESP: 1301 kvaser_usb_hydra_stop_chip_reply(dev, cmd); 1302 break; 1303 1304 case CMD_FLUSH_QUEUE_RESP: 1305 kvaser_usb_hydra_flush_queue_reply(dev, cmd); 1306 break; 1307 1308 case CMD_CHIP_STATE_EVENT: 1309 kvaser_usb_hydra_state_event(dev, cmd); 1310 break; 1311 1312 case CMD_ERROR_EVENT: 1313 kvaser_usb_hydra_error_event(dev, cmd); 1314 break; 1315 1316 case CMD_TX_ACKNOWLEDGE: 1317 kvaser_usb_hydra_tx_acknowledge(dev, cmd); 1318 break; 1319 1320 case CMD_RX_MESSAGE: 1321 kvaser_usb_hydra_rx_msg_std(dev, cmd); 1322 break; 1323 1324 /* Ignored commands */ 1325 case CMD_SET_BUSPARAMS_RESP: 1326 case CMD_SET_BUSPARAMS_FD_RESP: 1327 break; 1328 1329 default: 1330 dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", 1331 cmd->header.cmd_no); 1332 break; 1333 } 1334 } 1335 1336 static void kvaser_usb_hydra_handle_cmd_ext(const struct kvaser_usb *dev, 1337 const struct kvaser_cmd_ext *cmd) 1338 { 1339 switch (cmd->cmd_no_ext) { 1340 case CMD_TX_ACKNOWLEDGE_FD: 1341 kvaser_usb_hydra_tx_acknowledge(dev, (struct kvaser_cmd *)cmd); 1342 break; 1343 1344 case CMD_RX_MESSAGE_FD: 1345 kvaser_usb_hydra_rx_msg_ext(dev, cmd); 1346 break; 1347 1348 default: 1349 dev_warn(&dev->intf->dev, "Unhandled extended command (%d)\n", 1350 cmd->header.cmd_no); 1351 break; 1352 } 1353 } 1354 1355 static void kvaser_usb_hydra_handle_cmd(const struct kvaser_usb *dev, 1356 const struct kvaser_cmd *cmd) 1357 { 1358 if (cmd->header.cmd_no == CMD_EXTENDED) 1359 kvaser_usb_hydra_handle_cmd_ext 1360 (dev, (struct kvaser_cmd_ext *)cmd); 1361 else 1362 kvaser_usb_hydra_handle_cmd_std(dev, cmd); 1363 } 1364 1365 static void * 1366 kvaser_usb_hydra_frame_to_cmd_ext(const struct kvaser_usb_net_priv *priv, 1367 const struct sk_buff *skb, int *frame_len, 1368 int *cmd_len, u16 transid) 1369 { 1370 struct kvaser_usb *dev = priv->dev; 1371 struct kvaser_cmd_ext *cmd; 1372 struct canfd_frame *cf = (struct canfd_frame *)skb->data; 1373 u8 dlc = can_fd_len2dlc(cf->len); 1374 u8 nbr_of_bytes = cf->len; 1375 u32 flags; 1376 u32 id; 1377 u32 kcan_id; 1378 u32 kcan_header; 1379 1380 *frame_len = nbr_of_bytes; 1381 1382 cmd = kcalloc(1, sizeof(struct kvaser_cmd_ext), GFP_ATOMIC); 1383 if (!cmd) 1384 return NULL; 1385 1386 kvaser_usb_hydra_set_cmd_dest_he 1387 ((struct kvaser_cmd *)cmd, 1388 dev->card_data.hydra.channel_to_he[priv->channel]); 1389 kvaser_usb_hydra_set_cmd_transid((struct kvaser_cmd *)cmd, transid); 1390 1391 cmd->header.cmd_no = CMD_EXTENDED; 1392 cmd->cmd_no_ext = CMD_TX_CAN_MESSAGE_FD; 1393 1394 *cmd_len = ALIGN(sizeof(struct kvaser_cmd_ext) - 1395 sizeof(cmd->tx_can.kcan_payload) + nbr_of_bytes, 1396 8); 1397 1398 cmd->len = cpu_to_le16(*cmd_len); 1399 1400 cmd->tx_can.databytes = nbr_of_bytes; 1401 cmd->tx_can.dlc = dlc; 1402 1403 if (cf->can_id & CAN_EFF_FLAG) { 1404 id = cf->can_id & CAN_EFF_MASK; 1405 flags = KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID; 1406 kcan_id = (cf->can_id & CAN_EFF_MASK) | 1407 KVASER_USB_KCAN_DATA_IDE | KVASER_USB_KCAN_DATA_SRR; 1408 } else { 1409 id = cf->can_id & CAN_SFF_MASK; 1410 flags = 0; 1411 kcan_id = cf->can_id & CAN_SFF_MASK; 1412 } 1413 1414 if (cf->can_id & CAN_ERR_FLAG) 1415 flags |= KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME; 1416 1417 kcan_header = ((dlc << KVASER_USB_KCAN_DATA_DLC_SHIFT) & 1418 KVASER_USB_KCAN_DATA_DLC_MASK) | 1419 KVASER_USB_KCAN_DATA_AREQ | 1420 (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT ? 1421 KVASER_USB_KCAN_DATA_OSM : 0); 1422 1423 if (can_is_canfd_skb(skb)) { 1424 kcan_header |= KVASER_USB_KCAN_DATA_FDF | 1425 (cf->flags & CANFD_BRS ? 1426 KVASER_USB_KCAN_DATA_BRS : 0); 1427 } else { 1428 if (cf->can_id & CAN_RTR_FLAG) { 1429 kcan_id |= KVASER_USB_KCAN_DATA_RTR; 1430 cmd->tx_can.databytes = 0; 1431 flags |= KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME; 1432 } 1433 } 1434 1435 cmd->tx_can.kcan_id = cpu_to_le32(kcan_id); 1436 cmd->tx_can.id = cpu_to_le32(id); 1437 cmd->tx_can.flags = cpu_to_le32(flags); 1438 cmd->tx_can.kcan_header = cpu_to_le32(kcan_header); 1439 1440 memcpy(cmd->tx_can.kcan_payload, cf->data, nbr_of_bytes); 1441 1442 return cmd; 1443 } 1444 1445 static void * 1446 kvaser_usb_hydra_frame_to_cmd_std(const struct kvaser_usb_net_priv *priv, 1447 const struct sk_buff *skb, int *frame_len, 1448 int *cmd_len, u16 transid) 1449 { 1450 struct kvaser_usb *dev = priv->dev; 1451 struct kvaser_cmd *cmd; 1452 struct can_frame *cf = (struct can_frame *)skb->data; 1453 u32 flags; 1454 u32 id; 1455 1456 *frame_len = cf->len; 1457 1458 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_ATOMIC); 1459 if (!cmd) 1460 return NULL; 1461 1462 kvaser_usb_hydra_set_cmd_dest_he 1463 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]); 1464 kvaser_usb_hydra_set_cmd_transid(cmd, transid); 1465 1466 cmd->header.cmd_no = CMD_TX_CAN_MESSAGE; 1467 1468 *cmd_len = ALIGN(sizeof(struct kvaser_cmd), 8); 1469 1470 if (cf->can_id & CAN_EFF_FLAG) { 1471 id = (cf->can_id & CAN_EFF_MASK); 1472 id |= KVASER_USB_HYDRA_EXTENDED_FRAME_ID; 1473 } else { 1474 id = cf->can_id & CAN_SFF_MASK; 1475 } 1476 1477 cmd->tx_can.dlc = cf->len; 1478 1479 flags = (cf->can_id & CAN_EFF_FLAG ? 1480 KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID : 0); 1481 1482 if (cf->can_id & CAN_RTR_FLAG) 1483 flags |= KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME; 1484 1485 flags |= (cf->can_id & CAN_ERR_FLAG ? 1486 KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME : 0); 1487 1488 cmd->tx_can.id = cpu_to_le32(id); 1489 cmd->tx_can.flags = flags; 1490 1491 memcpy(cmd->tx_can.data, cf->data, *frame_len); 1492 1493 return cmd; 1494 } 1495 1496 static int kvaser_usb_hydra_set_mode(struct net_device *netdev, 1497 enum can_mode mode) 1498 { 1499 int err = 0; 1500 1501 switch (mode) { 1502 case CAN_MODE_START: 1503 /* CAN controller automatically recovers from BUS_OFF */ 1504 break; 1505 default: 1506 err = -EOPNOTSUPP; 1507 } 1508 1509 return err; 1510 } 1511 1512 static int kvaser_usb_hydra_set_bittiming(struct net_device *netdev) 1513 { 1514 struct kvaser_cmd *cmd; 1515 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1516 struct can_bittiming *bt = &priv->can.bittiming; 1517 struct kvaser_usb *dev = priv->dev; 1518 int tseg1 = bt->prop_seg + bt->phase_seg1; 1519 int tseg2 = bt->phase_seg2; 1520 int sjw = bt->sjw; 1521 int err; 1522 1523 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 1524 if (!cmd) 1525 return -ENOMEM; 1526 1527 cmd->header.cmd_no = CMD_SET_BUSPARAMS_REQ; 1528 cmd->set_busparams_req.bitrate = cpu_to_le32(bt->bitrate); 1529 cmd->set_busparams_req.sjw = (u8)sjw; 1530 cmd->set_busparams_req.tseg1 = (u8)tseg1; 1531 cmd->set_busparams_req.tseg2 = (u8)tseg2; 1532 cmd->set_busparams_req.nsamples = 1; 1533 1534 kvaser_usb_hydra_set_cmd_dest_he 1535 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]); 1536 kvaser_usb_hydra_set_cmd_transid 1537 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 1538 1539 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 1540 1541 kfree(cmd); 1542 1543 return err; 1544 } 1545 1546 static int kvaser_usb_hydra_set_data_bittiming(struct net_device *netdev) 1547 { 1548 struct kvaser_cmd *cmd; 1549 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1550 struct can_bittiming *dbt = &priv->can.data_bittiming; 1551 struct kvaser_usb *dev = priv->dev; 1552 int tseg1 = dbt->prop_seg + dbt->phase_seg1; 1553 int tseg2 = dbt->phase_seg2; 1554 int sjw = dbt->sjw; 1555 int err; 1556 1557 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 1558 if (!cmd) 1559 return -ENOMEM; 1560 1561 cmd->header.cmd_no = CMD_SET_BUSPARAMS_FD_REQ; 1562 cmd->set_busparams_req.bitrate_d = cpu_to_le32(dbt->bitrate); 1563 cmd->set_busparams_req.sjw_d = (u8)sjw; 1564 cmd->set_busparams_req.tseg1_d = (u8)tseg1; 1565 cmd->set_busparams_req.tseg2_d = (u8)tseg2; 1566 cmd->set_busparams_req.nsamples_d = 1; 1567 1568 if (priv->can.ctrlmode & CAN_CTRLMODE_FD) { 1569 if (priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO) 1570 cmd->set_busparams_req.canfd_mode = 1571 KVASER_USB_HYDRA_BUS_MODE_NONISO; 1572 else 1573 cmd->set_busparams_req.canfd_mode = 1574 KVASER_USB_HYDRA_BUS_MODE_CANFD_ISO; 1575 } 1576 1577 kvaser_usb_hydra_set_cmd_dest_he 1578 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]); 1579 kvaser_usb_hydra_set_cmd_transid 1580 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 1581 1582 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 1583 1584 kfree(cmd); 1585 1586 return err; 1587 } 1588 1589 static int kvaser_usb_hydra_get_berr_counter(const struct net_device *netdev, 1590 struct can_berr_counter *bec) 1591 { 1592 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1593 int err; 1594 1595 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, 1596 CMD_GET_CHIP_STATE_REQ, 1597 priv->channel); 1598 if (err) 1599 return err; 1600 1601 *bec = priv->bec; 1602 1603 return 0; 1604 } 1605 1606 static int kvaser_usb_hydra_setup_endpoints(struct kvaser_usb *dev) 1607 { 1608 const struct usb_host_interface *iface_desc; 1609 struct usb_endpoint_descriptor *ep; 1610 int i; 1611 1612 iface_desc = dev->intf->cur_altsetting; 1613 1614 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 1615 ep = &iface_desc->endpoint[i].desc; 1616 1617 if (!dev->bulk_in && usb_endpoint_is_bulk_in(ep) && 1618 ep->bEndpointAddress == KVASER_USB_HYDRA_BULK_EP_IN_ADDR) 1619 dev->bulk_in = ep; 1620 1621 if (!dev->bulk_out && usb_endpoint_is_bulk_out(ep) && 1622 ep->bEndpointAddress == KVASER_USB_HYDRA_BULK_EP_OUT_ADDR) 1623 dev->bulk_out = ep; 1624 1625 if (dev->bulk_in && dev->bulk_out) 1626 return 0; 1627 } 1628 1629 return -ENODEV; 1630 } 1631 1632 static int kvaser_usb_hydra_init_card(struct kvaser_usb *dev) 1633 { 1634 int err; 1635 unsigned int i; 1636 struct kvaser_usb_dev_card_data_hydra *card_data = 1637 &dev->card_data.hydra; 1638 1639 card_data->transid = KVASER_USB_HYDRA_MIN_TRANSID; 1640 spin_lock_init(&card_data->transid_lock); 1641 1642 memset(card_data->usb_rx_leftover, 0, KVASER_USB_HYDRA_MAX_CMD_LEN); 1643 card_data->usb_rx_leftover_len = 0; 1644 spin_lock_init(&card_data->usb_rx_leftover_lock); 1645 1646 memset(card_data->channel_to_he, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL, 1647 sizeof(card_data->channel_to_he)); 1648 card_data->sysdbg_he = 0; 1649 1650 for (i = 0; i < KVASER_USB_MAX_NET_DEVICES; i++) { 1651 err = kvaser_usb_hydra_map_channel 1652 (dev, 1653 (KVASER_USB_HYDRA_TRANSID_CANHE | i), 1654 i, "CAN"); 1655 if (err) { 1656 dev_err(&dev->intf->dev, 1657 "CMD_MAP_CHANNEL_REQ failed for CAN%u\n", i); 1658 return err; 1659 } 1660 } 1661 1662 err = kvaser_usb_hydra_map_channel(dev, KVASER_USB_HYDRA_TRANSID_SYSDBG, 1663 0, "SYSDBG"); 1664 if (err) { 1665 dev_err(&dev->intf->dev, 1666 "CMD_MAP_CHANNEL_REQ failed for SYSDBG\n"); 1667 return err; 1668 } 1669 1670 return 0; 1671 } 1672 1673 static int kvaser_usb_hydra_get_software_info(struct kvaser_usb *dev) 1674 { 1675 struct kvaser_cmd cmd; 1676 int err; 1677 1678 err = kvaser_usb_hydra_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO_REQ, 1679 -1); 1680 if (err) 1681 return err; 1682 1683 memset(&cmd, 0, sizeof(struct kvaser_cmd)); 1684 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_RESP, &cmd); 1685 if (err) 1686 return err; 1687 1688 dev->max_tx_urbs = min_t(unsigned int, KVASER_USB_MAX_TX_URBS, 1689 le16_to_cpu(cmd.sw_info.max_outstanding_tx)); 1690 1691 return 0; 1692 } 1693 1694 static int kvaser_usb_hydra_get_software_details(struct kvaser_usb *dev) 1695 { 1696 struct kvaser_cmd *cmd; 1697 int err; 1698 u32 flags; 1699 struct kvaser_usb_dev_card_data *card_data = &dev->card_data; 1700 1701 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 1702 if (!cmd) 1703 return -ENOMEM; 1704 1705 cmd->header.cmd_no = CMD_GET_SOFTWARE_DETAILS_REQ; 1706 cmd->sw_detail_req.use_ext_cmd = 1; 1707 kvaser_usb_hydra_set_cmd_dest_he 1708 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL); 1709 1710 kvaser_usb_hydra_set_cmd_transid 1711 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 1712 1713 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 1714 if (err) 1715 goto end; 1716 1717 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_SOFTWARE_DETAILS_RESP, 1718 cmd); 1719 if (err) 1720 goto end; 1721 1722 dev->fw_version = le32_to_cpu(cmd->sw_detail_res.sw_version); 1723 flags = le32_to_cpu(cmd->sw_detail_res.sw_flags); 1724 1725 if (flags & KVASER_USB_HYDRA_SW_FLAG_FW_BAD) { 1726 dev_err(&dev->intf->dev, 1727 "Bad firmware, device refuse to run!\n"); 1728 err = -EINVAL; 1729 goto end; 1730 } 1731 1732 if (flags & KVASER_USB_HYDRA_SW_FLAG_FW_BETA) 1733 dev_info(&dev->intf->dev, "Beta firmware in use\n"); 1734 1735 if (flags & KVASER_USB_HYDRA_SW_FLAG_EXT_CAP) 1736 card_data->capabilities |= KVASER_USB_CAP_EXT_CAP; 1737 1738 if (flags & KVASER_USB_HYDRA_SW_FLAG_EXT_CMD) 1739 card_data->capabilities |= KVASER_USB_HYDRA_CAP_EXT_CMD; 1740 1741 if (flags & KVASER_USB_HYDRA_SW_FLAG_CANFD) 1742 card_data->ctrlmode_supported |= CAN_CTRLMODE_FD; 1743 1744 if (flags & KVASER_USB_HYDRA_SW_FLAG_NONISO) 1745 card_data->ctrlmode_supported |= CAN_CTRLMODE_FD_NON_ISO; 1746 1747 if (flags & KVASER_USB_HYDRA_SW_FLAG_FREQ_80M) 1748 dev->cfg = &kvaser_usb_hydra_dev_cfg_kcan; 1749 else if (flags & KVASER_USB_HYDRA_SW_FLAG_CAN_FREQ_80M) 1750 dev->cfg = &kvaser_usb_hydra_dev_cfg_rt; 1751 else 1752 dev->cfg = &kvaser_usb_hydra_dev_cfg_flexc; 1753 1754 end: 1755 kfree(cmd); 1756 1757 return err; 1758 } 1759 1760 static int kvaser_usb_hydra_get_card_info(struct kvaser_usb *dev) 1761 { 1762 struct kvaser_cmd cmd; 1763 int err; 1764 1765 err = kvaser_usb_hydra_send_simple_cmd(dev, CMD_GET_CARD_INFO_REQ, -1); 1766 if (err) 1767 return err; 1768 1769 memset(&cmd, 0, sizeof(struct kvaser_cmd)); 1770 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_CARD_INFO_RESP, &cmd); 1771 if (err) 1772 return err; 1773 1774 dev->nchannels = cmd.card_info.nchannels; 1775 if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES) 1776 return -EINVAL; 1777 1778 return 0; 1779 } 1780 1781 static int kvaser_usb_hydra_get_capabilities(struct kvaser_usb *dev) 1782 { 1783 int err; 1784 u16 status; 1785 1786 if (!(dev->card_data.capabilities & KVASER_USB_CAP_EXT_CAP)) { 1787 dev_info(&dev->intf->dev, 1788 "No extended capability support. Upgrade your device.\n"); 1789 return 0; 1790 } 1791 1792 err = kvaser_usb_hydra_get_single_capability 1793 (dev, 1794 KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE, 1795 &status); 1796 if (err) 1797 return err; 1798 if (status) 1799 dev_info(&dev->intf->dev, 1800 "KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE failed %u\n", 1801 status); 1802 1803 err = kvaser_usb_hydra_get_single_capability 1804 (dev, 1805 KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT, 1806 &status); 1807 if (err) 1808 return err; 1809 if (status) 1810 dev_info(&dev->intf->dev, 1811 "KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT failed %u\n", 1812 status); 1813 1814 err = kvaser_usb_hydra_get_single_capability 1815 (dev, KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT, 1816 &status); 1817 if (err) 1818 return err; 1819 if (status) 1820 dev_info(&dev->intf->dev, 1821 "KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT failed %u\n", 1822 status); 1823 1824 return 0; 1825 } 1826 1827 static int kvaser_usb_hydra_set_opt_mode(const struct kvaser_usb_net_priv *priv) 1828 { 1829 struct kvaser_usb *dev = priv->dev; 1830 struct kvaser_cmd *cmd; 1831 int err; 1832 1833 if ((priv->can.ctrlmode & 1834 (CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO)) == 1835 CAN_CTRLMODE_FD_NON_ISO) { 1836 netdev_warn(priv->netdev, 1837 "CTRLMODE_FD shall be on if CTRLMODE_FD_NON_ISO is on\n"); 1838 return -EINVAL; 1839 } 1840 1841 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL); 1842 if (!cmd) 1843 return -ENOMEM; 1844 1845 cmd->header.cmd_no = CMD_SET_DRIVERMODE_REQ; 1846 kvaser_usb_hydra_set_cmd_dest_he 1847 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]); 1848 kvaser_usb_hydra_set_cmd_transid 1849 (cmd, kvaser_usb_hydra_get_next_transid(dev)); 1850 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1851 cmd->set_ctrlmode.mode = KVASER_USB_HYDRA_CTRLMODE_LISTEN; 1852 else 1853 cmd->set_ctrlmode.mode = KVASER_USB_HYDRA_CTRLMODE_NORMAL; 1854 1855 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd)); 1856 kfree(cmd); 1857 1858 return err; 1859 } 1860 1861 static int kvaser_usb_hydra_start_chip(struct kvaser_usb_net_priv *priv) 1862 { 1863 int err; 1864 1865 init_completion(&priv->start_comp); 1866 1867 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_START_CHIP_REQ, 1868 priv->channel); 1869 if (err) 1870 return err; 1871 1872 if (!wait_for_completion_timeout(&priv->start_comp, 1873 msecs_to_jiffies(KVASER_USB_TIMEOUT))) 1874 return -ETIMEDOUT; 1875 1876 return 0; 1877 } 1878 1879 static int kvaser_usb_hydra_stop_chip(struct kvaser_usb_net_priv *priv) 1880 { 1881 int err; 1882 1883 init_completion(&priv->stop_comp); 1884 1885 /* Make sure we do not report invalid BUS_OFF from CMD_CHIP_STATE_EVENT 1886 * see comment in kvaser_usb_hydra_update_state() 1887 */ 1888 priv->can.state = CAN_STATE_STOPPED; 1889 1890 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_STOP_CHIP_REQ, 1891 priv->channel); 1892 if (err) 1893 return err; 1894 1895 if (!wait_for_completion_timeout(&priv->stop_comp, 1896 msecs_to_jiffies(KVASER_USB_TIMEOUT))) 1897 return -ETIMEDOUT; 1898 1899 return 0; 1900 } 1901 1902 static int kvaser_usb_hydra_flush_queue(struct kvaser_usb_net_priv *priv) 1903 { 1904 int err; 1905 1906 init_completion(&priv->flush_comp); 1907 1908 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_FLUSH_QUEUE, 1909 priv->channel); 1910 if (err) 1911 return err; 1912 1913 if (!wait_for_completion_timeout(&priv->flush_comp, 1914 msecs_to_jiffies(KVASER_USB_TIMEOUT))) 1915 return -ETIMEDOUT; 1916 1917 return 0; 1918 } 1919 1920 /* A single extended hydra command can be transmitted in multiple transfers 1921 * We have to buffer partial hydra commands, and handle them on next callback. 1922 */ 1923 static void kvaser_usb_hydra_read_bulk_callback(struct kvaser_usb *dev, 1924 void *buf, int len) 1925 { 1926 unsigned long irq_flags; 1927 struct kvaser_cmd *cmd; 1928 int pos = 0; 1929 size_t cmd_len; 1930 struct kvaser_usb_dev_card_data_hydra *card_data = 1931 &dev->card_data.hydra; 1932 int usb_rx_leftover_len; 1933 spinlock_t *usb_rx_leftover_lock = &card_data->usb_rx_leftover_lock; 1934 1935 spin_lock_irqsave(usb_rx_leftover_lock, irq_flags); 1936 usb_rx_leftover_len = card_data->usb_rx_leftover_len; 1937 if (usb_rx_leftover_len) { 1938 int remaining_bytes; 1939 1940 cmd = (struct kvaser_cmd *)card_data->usb_rx_leftover; 1941 1942 cmd_len = kvaser_usb_hydra_cmd_size(cmd); 1943 1944 remaining_bytes = min_t(unsigned int, len, 1945 cmd_len - usb_rx_leftover_len); 1946 /* Make sure we do not overflow usb_rx_leftover */ 1947 if (remaining_bytes + usb_rx_leftover_len > 1948 KVASER_USB_HYDRA_MAX_CMD_LEN) { 1949 dev_err(&dev->intf->dev, "Format error\n"); 1950 spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags); 1951 return; 1952 } 1953 1954 memcpy(card_data->usb_rx_leftover + usb_rx_leftover_len, buf, 1955 remaining_bytes); 1956 pos += remaining_bytes; 1957 1958 if (remaining_bytes + usb_rx_leftover_len == cmd_len) { 1959 kvaser_usb_hydra_handle_cmd(dev, cmd); 1960 usb_rx_leftover_len = 0; 1961 } else { 1962 /* Command still not complete */ 1963 usb_rx_leftover_len += remaining_bytes; 1964 } 1965 card_data->usb_rx_leftover_len = usb_rx_leftover_len; 1966 } 1967 spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags); 1968 1969 while (pos < len) { 1970 cmd = buf + pos; 1971 1972 cmd_len = kvaser_usb_hydra_cmd_size(cmd); 1973 1974 if (pos + cmd_len > len) { 1975 /* We got first part of a command */ 1976 int leftover_bytes; 1977 1978 leftover_bytes = len - pos; 1979 /* Make sure we do not overflow usb_rx_leftover */ 1980 if (leftover_bytes > KVASER_USB_HYDRA_MAX_CMD_LEN) { 1981 dev_err(&dev->intf->dev, "Format error\n"); 1982 return; 1983 } 1984 spin_lock_irqsave(usb_rx_leftover_lock, irq_flags); 1985 memcpy(card_data->usb_rx_leftover, buf + pos, 1986 leftover_bytes); 1987 card_data->usb_rx_leftover_len = leftover_bytes; 1988 spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags); 1989 break; 1990 } 1991 1992 kvaser_usb_hydra_handle_cmd(dev, cmd); 1993 pos += cmd_len; 1994 } 1995 } 1996 1997 static void * 1998 kvaser_usb_hydra_frame_to_cmd(const struct kvaser_usb_net_priv *priv, 1999 const struct sk_buff *skb, int *frame_len, 2000 int *cmd_len, u16 transid) 2001 { 2002 void *buf; 2003 2004 if (priv->dev->card_data.capabilities & KVASER_USB_HYDRA_CAP_EXT_CMD) 2005 buf = kvaser_usb_hydra_frame_to_cmd_ext(priv, skb, frame_len, 2006 cmd_len, transid); 2007 else 2008 buf = kvaser_usb_hydra_frame_to_cmd_std(priv, skb, frame_len, 2009 cmd_len, transid); 2010 2011 return buf; 2012 } 2013 2014 const struct kvaser_usb_dev_ops kvaser_usb_hydra_dev_ops = { 2015 .dev_set_mode = kvaser_usb_hydra_set_mode, 2016 .dev_set_bittiming = kvaser_usb_hydra_set_bittiming, 2017 .dev_set_data_bittiming = kvaser_usb_hydra_set_data_bittiming, 2018 .dev_get_berr_counter = kvaser_usb_hydra_get_berr_counter, 2019 .dev_setup_endpoints = kvaser_usb_hydra_setup_endpoints, 2020 .dev_init_card = kvaser_usb_hydra_init_card, 2021 .dev_get_software_info = kvaser_usb_hydra_get_software_info, 2022 .dev_get_software_details = kvaser_usb_hydra_get_software_details, 2023 .dev_get_card_info = kvaser_usb_hydra_get_card_info, 2024 .dev_get_capabilities = kvaser_usb_hydra_get_capabilities, 2025 .dev_set_opt_mode = kvaser_usb_hydra_set_opt_mode, 2026 .dev_start_chip = kvaser_usb_hydra_start_chip, 2027 .dev_stop_chip = kvaser_usb_hydra_stop_chip, 2028 .dev_reset_chip = NULL, 2029 .dev_flush_queue = kvaser_usb_hydra_flush_queue, 2030 .dev_read_bulk_callback = kvaser_usb_hydra_read_bulk_callback, 2031 .dev_frame_to_cmd = kvaser_usb_hydra_frame_to_cmd, 2032 }; 2033 2034 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_kcan = { 2035 .clock = { 2036 .freq = 80 * MEGA /* Hz */, 2037 }, 2038 .timestamp_freq = 80, 2039 .bittiming_const = &kvaser_usb_hydra_kcan_bittiming_c, 2040 .data_bittiming_const = &kvaser_usb_hydra_kcan_bittiming_c, 2041 }; 2042 2043 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_flexc = { 2044 .clock = { 2045 .freq = 24 * MEGA /* Hz */, 2046 }, 2047 .timestamp_freq = 1, 2048 .bittiming_const = &kvaser_usb_hydra_flexc_bittiming_c, 2049 }; 2050 2051 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_rt = { 2052 .clock = { 2053 .freq = 80 * MEGA /* Hz */, 2054 }, 2055 .timestamp_freq = 24, 2056 .bittiming_const = &kvaser_usb_hydra_rt_bittiming_c, 2057 .data_bittiming_const = &kvaser_usb_hydra_rtd_bittiming_c, 2058 }; 2059