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