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