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