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