1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * CAN driver for esd electronics gmbh CAN-USB/2, CAN-USB/3 and CAN-USB/Micro 4 * 5 * Copyright (C) 2010-2012 esd electronic system design gmbh, Matthias Fuchs <socketcan@esd.eu> 6 * Copyright (C) 2022-2024 esd electronics gmbh, Frank Jungclaus <frank.jungclaus@esd.eu> 7 */ 8 9 #include <linux/can.h> 10 #include <linux/can/dev.h> 11 #include <linux/can/error.h> 12 #include <linux/err.h> 13 #include <linux/ethtool.h> 14 #include <linux/module.h> 15 #include <linux/netdevice.h> 16 #include <linux/signal.h> 17 #include <linux/slab.h> 18 #include <linux/units.h> 19 #include <linux/usb.h> 20 21 MODULE_AUTHOR("Matthias Fuchs <socketcan@esd.eu>"); 22 MODULE_AUTHOR("Frank Jungclaus <frank.jungclaus@esd.eu>"); 23 MODULE_DESCRIPTION("CAN driver for esd electronics gmbh CAN-USB/2, CAN-USB/3 and CAN-USB/Micro interfaces"); 24 MODULE_LICENSE("GPL v2"); 25 26 /* USB vendor and product ID */ 27 #define ESD_USB_ESDGMBH_VENDOR_ID 0x0ab4 28 #define ESD_USB_CANUSB2_PRODUCT_ID 0x0010 29 #define ESD_USB_CANUSBM_PRODUCT_ID 0x0011 30 #define ESD_USB_CANUSB3_PRODUCT_ID 0x0014 31 32 /* CAN controller clock frequencies */ 33 #define ESD_USB_2_CAN_CLOCK (60 * MEGA) /* Hz */ 34 #define ESD_USB_M_CAN_CLOCK (36 * MEGA) /* Hz */ 35 #define ESD_USB_3_CAN_CLOCK (80 * MEGA) /* Hz */ 36 37 /* Maximum number of CAN nets */ 38 #define ESD_USB_MAX_NETS 2 39 40 /* USB commands */ 41 #define ESD_USB_CMD_VERSION 1 /* also used for VERSION_REPLY */ 42 #define ESD_USB_CMD_CAN_RX 2 /* device to host only */ 43 #define ESD_USB_CMD_CAN_TX 3 /* also used for TX_DONE */ 44 #define ESD_USB_CMD_SETBAUD 4 /* also used for SETBAUD_REPLY */ 45 #define ESD_USB_CMD_TS 5 /* also used for TS_REPLY */ 46 #define ESD_USB_CMD_IDADD 6 /* also used for IDADD_REPLY */ 47 48 /* esd CAN message flags - dlc field */ 49 #define ESD_USB_RTR BIT(4) 50 #define ESD_USB_NO_BRS BIT(4) 51 #define ESD_USB_ESI BIT(5) 52 #define ESD_USB_FD BIT(7) 53 54 /* esd CAN message flags - id field */ 55 #define ESD_USB_EXTID BIT(29) 56 #define ESD_USB_EVENT BIT(30) 57 #define ESD_USB_IDMASK GENMASK(28, 0) 58 59 /* esd CAN event ids */ 60 #define ESD_USB_EV_CAN_ERROR_EXT 2 /* CAN controller specific diagnostic data */ 61 62 /* baudrate message flags */ 63 #define ESD_USB_LOM BIT(30) /* Listen Only Mode */ 64 #define ESD_USB_UBR BIT(31) /* User Bit Rate (controller BTR) in bits 0..27 */ 65 #define ESD_USB_NO_BAUDRATE GENMASK(30, 0) /* bit rate unconfigured */ 66 67 /* bit timing esd CAN-USB */ 68 #define ESD_USB_2_TSEG1_SHIFT 16 69 #define ESD_USB_2_TSEG2_SHIFT 20 70 #define ESD_USB_2_SJW_SHIFT 14 71 #define ESD_USB_M_SJW_SHIFT 24 72 #define ESD_USB_TRIPLE_SAMPLES BIT(23) 73 74 /* Transmitter Delay Compensation */ 75 #define ESD_USB_3_TDC_MODE_AUTO 0 76 77 /* esd IDADD message */ 78 #define ESD_USB_ID_ENABLE BIT(7) 79 #define ESD_USB_MAX_ID_SEGMENT 64 80 81 /* SJA1000 ECC register (emulated by usb firmware) */ 82 #define ESD_USB_SJA1000_ECC_SEG GENMASK(4, 0) 83 #define ESD_USB_SJA1000_ECC_DIR BIT(5) 84 #define ESD_USB_SJA1000_ECC_ERR BIT(2, 1) 85 #define ESD_USB_SJA1000_ECC_BIT 0x00 86 #define ESD_USB_SJA1000_ECC_FORM BIT(6) 87 #define ESD_USB_SJA1000_ECC_STUFF BIT(7) 88 #define ESD_USB_SJA1000_ECC_MASK GENMASK(7, 6) 89 90 /* esd bus state event codes */ 91 #define ESD_USB_BUSSTATE_MASK GENMASK(7, 6) 92 #define ESD_USB_BUSSTATE_WARN BIT(6) 93 #define ESD_USB_BUSSTATE_ERRPASSIVE BIT(7) 94 #define ESD_USB_BUSSTATE_BUSOFF GENMASK(7, 6) 95 96 #define ESD_USB_RX_BUFFER_SIZE 1024 97 #define ESD_USB_MAX_RX_URBS 4 98 #define ESD_USB_MAX_TX_URBS 16 /* must be power of 2 */ 99 100 /* Modes for CAN-USB/3, to be used for esd_usb_3_set_baudrate_msg_x.mode */ 101 #define ESD_USB_3_BAUDRATE_MODE_DISABLE 0 /* remove from bus */ 102 #define ESD_USB_3_BAUDRATE_MODE_INDEX 1 /* ESD (CiA) bit rate idx */ 103 #define ESD_USB_3_BAUDRATE_MODE_BTR_CTRL 2 /* BTR values (controller)*/ 104 #define ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL 3 /* BTR values (canonical) */ 105 #define ESD_USB_3_BAUDRATE_MODE_NUM 4 /* numerical bit rate */ 106 #define ESD_USB_3_BAUDRATE_MODE_AUTOBAUD 5 /* autobaud */ 107 108 /* Flags for CAN-USB/3, to be used for esd_usb_3_set_baudrate_msg_x.flags */ 109 #define ESD_USB_3_BAUDRATE_FLAG_FD BIT(0) /* enable CAN FD mode */ 110 #define ESD_USB_3_BAUDRATE_FLAG_LOM BIT(1) /* enable listen only mode */ 111 #define ESD_USB_3_BAUDRATE_FLAG_STM BIT(2) /* enable self test mode */ 112 #define ESD_USB_3_BAUDRATE_FLAG_TRS BIT(3) /* enable triple sampling */ 113 #define ESD_USB_3_BAUDRATE_FLAG_TXP BIT(4) /* enable transmit pause */ 114 115 struct esd_usb_header_msg { 116 u8 len; /* total message length in 32bit words */ 117 u8 cmd; 118 u8 rsvd[2]; 119 }; 120 121 struct esd_usb_version_msg { 122 u8 len; /* total message length in 32bit words */ 123 u8 cmd; 124 u8 rsvd; 125 u8 flags; 126 __le32 drv_version; 127 }; 128 129 struct esd_usb_version_reply_msg { 130 u8 len; /* total message length in 32bit words */ 131 u8 cmd; 132 u8 nets; 133 u8 features; 134 __le32 version; 135 u8 name[16]; 136 __le32 rsvd; 137 __le32 ts; 138 }; 139 140 struct esd_usb_rx_msg { 141 u8 len; /* total message length in 32bit words */ 142 u8 cmd; 143 u8 net; 144 u8 dlc; 145 __le32 ts; 146 __le32 id; /* upper 3 bits contain flags */ 147 union { 148 u8 data[CAN_MAX_DLEN]; 149 u8 data_fd[CANFD_MAX_DLEN]; 150 struct { 151 u8 status; /* CAN Controller Status */ 152 u8 ecc; /* Error Capture Register */ 153 u8 rec; /* RX Error Counter */ 154 u8 tec; /* TX Error Counter */ 155 } ev_can_err_ext; /* For ESD_EV_CAN_ERROR_EXT */ 156 }; 157 }; 158 159 struct esd_usb_tx_msg { 160 u8 len; /* total message length in 32bit words */ 161 u8 cmd; 162 u8 net; 163 u8 dlc; 164 u32 hnd; /* opaque handle, not used by device */ 165 __le32 id; /* upper 3 bits contain flags */ 166 union { 167 u8 data[CAN_MAX_DLEN]; 168 u8 data_fd[CANFD_MAX_DLEN]; 169 }; 170 }; 171 172 struct esd_usb_tx_done_msg { 173 u8 len; /* total message length in 32bit words */ 174 u8 cmd; 175 u8 net; 176 u8 status; 177 u32 hnd; /* opaque handle, not used by device */ 178 __le32 ts; 179 }; 180 181 struct esd_usb_id_filter_msg { 182 u8 len; /* total message length in 32bit words */ 183 u8 cmd; 184 u8 net; 185 u8 option; 186 __le32 mask[ESD_USB_MAX_ID_SEGMENT + 1]; /* +1 for 29bit extended IDs */ 187 }; 188 189 struct esd_usb_set_baudrate_msg { 190 u8 len; /* total message length in 32bit words */ 191 u8 cmd; 192 u8 net; 193 u8 rsvd; 194 __le32 baud; 195 }; 196 197 /* CAN-USB/3 baudrate configuration, used for nominal as well as for data bit rate */ 198 struct esd_usb_3_baudrate_cfg { 199 __le16 brp; /* bit rate pre-scaler */ 200 __le16 tseg1; /* time segment before sample point */ 201 __le16 tseg2; /* time segment after sample point */ 202 __le16 sjw; /* synchronization jump Width */ 203 }; 204 205 /* In principle, the esd CAN-USB/3 supports Transmitter Delay Compensation (TDC), 206 * but currently only the automatic TDC mode is supported by this driver. 207 * An implementation for manual TDC configuration will follow. 208 * 209 * For information about struct esd_usb_3_tdc_cfg, see 210 * NTCAN Application Developers Manual, 6.2.25 NTCAN_TDC_CFG + related chapters 211 * https://esd.eu/fileadmin/esd/docs/manuals/NTCAN_Part1_Function_API_Manual_en_56.pdf 212 */ 213 struct esd_usb_3_tdc_cfg { 214 u8 tdc_mode; /* transmitter delay compensation mode */ 215 u8 ssp_offset; /* secondary sample point offset in mtq */ 216 s8 ssp_shift; /* secondary sample point shift in mtq */ 217 u8 tdc_filter; /* TDC filter in mtq */ 218 }; 219 220 /* Extended version of the above set_baudrate_msg for a CAN-USB/3 221 * to define the CAN bit timing configuration of the CAN controller in 222 * CAN FD mode as well as in Classical CAN mode. 223 * 224 * The payload of this command is a NTCAN_BAUDRATE_X structure according to 225 * esd electronics gmbh, NTCAN Application Developers Manual, 6.2.15 NTCAN_BAUDRATE_X 226 * https://esd.eu/fileadmin/esd/docs/manuals/NTCAN_Part1_Function_API_Manual_en_56.pdf 227 */ 228 struct esd_usb_3_set_baudrate_msg_x { 229 u8 len; /* total message length in 32bit words */ 230 u8 cmd; 231 u8 net; 232 u8 rsvd; /*reserved */ 233 /* Payload ... */ 234 __le16 mode; /* mode word, see ESD_USB_3_BAUDRATE_MODE_xxx */ 235 __le16 flags; /* control flags, see ESD_USB_3_BAUDRATE_FLAG_xxx */ 236 struct esd_usb_3_tdc_cfg tdc; /* TDC configuration */ 237 struct esd_usb_3_baudrate_cfg nom; /* nominal bit rate */ 238 struct esd_usb_3_baudrate_cfg data; /* data bit rate */ 239 }; 240 241 /* Main message type used between library and application */ 242 union __packed esd_usb_msg { 243 struct esd_usb_header_msg hdr; 244 struct esd_usb_version_msg version; 245 struct esd_usb_version_reply_msg version_reply; 246 struct esd_usb_rx_msg rx; 247 struct esd_usb_tx_msg tx; 248 struct esd_usb_tx_done_msg txdone; 249 struct esd_usb_set_baudrate_msg setbaud; 250 struct esd_usb_3_set_baudrate_msg_x setbaud_x; 251 struct esd_usb_id_filter_msg filter; 252 }; 253 254 static struct usb_device_id esd_usb_table[] = { 255 {USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSB2_PRODUCT_ID)}, 256 {USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSBM_PRODUCT_ID)}, 257 {USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSB3_PRODUCT_ID)}, 258 {} 259 }; 260 MODULE_DEVICE_TABLE(usb, esd_usb_table); 261 262 struct esd_usb_net_priv; 263 264 struct esd_tx_urb_context { 265 struct esd_usb_net_priv *priv; 266 u32 echo_index; 267 }; 268 269 struct esd_usb { 270 struct usb_device *udev; 271 struct esd_usb_net_priv *nets[ESD_USB_MAX_NETS]; 272 273 struct usb_anchor rx_submitted; 274 275 int net_count; 276 u32 version; 277 int rxinitdone; 278 int in_usb_disconnect; 279 void *rxbuf[ESD_USB_MAX_RX_URBS]; 280 dma_addr_t rxbuf_dma[ESD_USB_MAX_RX_URBS]; 281 }; 282 283 struct esd_usb_net_priv { 284 struct can_priv can; /* must be the first member */ 285 286 atomic_t active_tx_jobs; 287 struct usb_anchor tx_submitted; 288 struct esd_tx_urb_context tx_contexts[ESD_USB_MAX_TX_URBS]; 289 290 struct esd_usb *usb; 291 struct net_device *netdev; 292 int index; 293 u8 old_state; 294 struct can_berr_counter bec; 295 }; 296 297 static void esd_usb_rx_event(struct esd_usb_net_priv *priv, 298 union esd_usb_msg *msg) 299 { 300 struct net_device_stats *stats = &priv->netdev->stats; 301 struct can_frame *cf; 302 struct sk_buff *skb; 303 u32 id = le32_to_cpu(msg->rx.id) & ESD_USB_IDMASK; 304 305 if (id == ESD_USB_EV_CAN_ERROR_EXT) { 306 u8 state = msg->rx.ev_can_err_ext.status; 307 u8 ecc = msg->rx.ev_can_err_ext.ecc; 308 309 priv->bec.rxerr = msg->rx.ev_can_err_ext.rec; 310 priv->bec.txerr = msg->rx.ev_can_err_ext.tec; 311 312 netdev_dbg(priv->netdev, 313 "CAN_ERR_EV_EXT: dlc=%#02x state=%02x ecc=%02x rec=%02x tec=%02x\n", 314 msg->rx.dlc, state, ecc, 315 priv->bec.rxerr, priv->bec.txerr); 316 317 /* if berr-reporting is off, only pass through on state change ... */ 318 if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) && 319 state == priv->old_state) 320 return; 321 322 skb = alloc_can_err_skb(priv->netdev, &cf); 323 if (!skb) 324 stats->rx_dropped++; 325 326 if (state != priv->old_state) { 327 enum can_state tx_state, rx_state; 328 enum can_state new_state = CAN_STATE_ERROR_ACTIVE; 329 330 priv->old_state = state; 331 332 switch (state & ESD_USB_BUSSTATE_MASK) { 333 case ESD_USB_BUSSTATE_BUSOFF: 334 new_state = CAN_STATE_BUS_OFF; 335 can_bus_off(priv->netdev); 336 break; 337 case ESD_USB_BUSSTATE_WARN: 338 new_state = CAN_STATE_ERROR_WARNING; 339 break; 340 case ESD_USB_BUSSTATE_ERRPASSIVE: 341 new_state = CAN_STATE_ERROR_PASSIVE; 342 break; 343 default: 344 new_state = CAN_STATE_ERROR_ACTIVE; 345 priv->bec.txerr = 0; 346 priv->bec.rxerr = 0; 347 break; 348 } 349 350 if (new_state != priv->can.state) { 351 tx_state = (priv->bec.txerr >= priv->bec.rxerr) ? new_state : 0; 352 rx_state = (priv->bec.txerr <= priv->bec.rxerr) ? new_state : 0; 353 can_change_state(priv->netdev, cf, 354 tx_state, rx_state); 355 } 356 } else if (skb) { 357 priv->can.can_stats.bus_error++; 358 stats->rx_errors++; 359 360 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 361 362 switch (ecc & ESD_USB_SJA1000_ECC_MASK) { 363 case ESD_USB_SJA1000_ECC_BIT: 364 cf->data[2] |= CAN_ERR_PROT_BIT; 365 break; 366 case ESD_USB_SJA1000_ECC_FORM: 367 cf->data[2] |= CAN_ERR_PROT_FORM; 368 break; 369 case ESD_USB_SJA1000_ECC_STUFF: 370 cf->data[2] |= CAN_ERR_PROT_STUFF; 371 break; 372 default: 373 break; 374 } 375 376 /* Error occurred during transmission? */ 377 if (!(ecc & ESD_USB_SJA1000_ECC_DIR)) 378 cf->data[2] |= CAN_ERR_PROT_TX; 379 380 /* Bit stream position in CAN frame as the error was detected */ 381 cf->data[3] = ecc & ESD_USB_SJA1000_ECC_SEG; 382 } 383 384 if (skb) { 385 cf->can_id |= CAN_ERR_CNT; 386 cf->data[6] = priv->bec.txerr; 387 cf->data[7] = priv->bec.rxerr; 388 389 netif_rx(skb); 390 } 391 } 392 } 393 394 static void esd_usb_rx_can_msg(struct esd_usb_net_priv *priv, 395 union esd_usb_msg *msg) 396 { 397 struct net_device_stats *stats = &priv->netdev->stats; 398 struct can_frame *cf; 399 struct canfd_frame *cfd; 400 struct sk_buff *skb; 401 u32 id; 402 u8 len; 403 404 if (!netif_device_present(priv->netdev)) 405 return; 406 407 id = le32_to_cpu(msg->rx.id); 408 409 if (id & ESD_USB_EVENT) { 410 esd_usb_rx_event(priv, msg); 411 } else { 412 if (msg->rx.dlc & ESD_USB_FD) { 413 skb = alloc_canfd_skb(priv->netdev, &cfd); 414 } else { 415 skb = alloc_can_skb(priv->netdev, &cf); 416 cfd = (struct canfd_frame *)cf; 417 } 418 419 if (skb == NULL) { 420 stats->rx_dropped++; 421 return; 422 } 423 424 cfd->can_id = id & ESD_USB_IDMASK; 425 426 if (msg->rx.dlc & ESD_USB_FD) { 427 /* masking by 0x0F is already done within can_fd_dlc2len() */ 428 cfd->len = can_fd_dlc2len(msg->rx.dlc); 429 len = cfd->len; 430 if ((msg->rx.dlc & ESD_USB_NO_BRS) == 0) 431 cfd->flags |= CANFD_BRS; 432 if (msg->rx.dlc & ESD_USB_ESI) 433 cfd->flags |= CANFD_ESI; 434 } else { 435 can_frame_set_cc_len(cf, msg->rx.dlc & ~ESD_USB_RTR, priv->can.ctrlmode); 436 len = cf->len; 437 if (msg->rx.dlc & ESD_USB_RTR) { 438 cf->can_id |= CAN_RTR_FLAG; 439 len = 0; 440 } 441 } 442 443 if (id & ESD_USB_EXTID) 444 cfd->can_id |= CAN_EFF_FLAG; 445 446 memcpy(cfd->data, msg->rx.data_fd, len); 447 stats->rx_bytes += len; 448 stats->rx_packets++; 449 450 netif_rx(skb); 451 } 452 } 453 454 static void esd_usb_tx_done_msg(struct esd_usb_net_priv *priv, 455 union esd_usb_msg *msg) 456 { 457 struct net_device_stats *stats = &priv->netdev->stats; 458 struct net_device *netdev = priv->netdev; 459 struct esd_tx_urb_context *context; 460 461 if (!netif_device_present(netdev)) 462 return; 463 464 context = &priv->tx_contexts[msg->txdone.hnd & (ESD_USB_MAX_TX_URBS - 1)]; 465 466 if (!msg->txdone.status) { 467 stats->tx_packets++; 468 stats->tx_bytes += can_get_echo_skb(netdev, context->echo_index, 469 NULL); 470 } else { 471 stats->tx_errors++; 472 can_free_echo_skb(netdev, context->echo_index, NULL); 473 } 474 475 /* Release context */ 476 context->echo_index = ESD_USB_MAX_TX_URBS; 477 atomic_dec(&priv->active_tx_jobs); 478 479 netif_wake_queue(netdev); 480 } 481 482 static void esd_usb_read_bulk_callback(struct urb *urb) 483 { 484 struct esd_usb *dev = urb->context; 485 int err; 486 int pos = 0; 487 int i; 488 489 switch (urb->status) { 490 case 0: /* success */ 491 break; 492 493 case -ENOENT: 494 case -EPIPE: 495 case -EPROTO: 496 case -ESHUTDOWN: 497 return; 498 499 default: 500 dev_info(dev->udev->dev.parent, 501 "Rx URB aborted (%pe)\n", ERR_PTR(urb->status)); 502 goto resubmit_urb; 503 } 504 505 while (pos < urb->actual_length) { 506 union esd_usb_msg *msg; 507 508 msg = (union esd_usb_msg *)(urb->transfer_buffer + pos); 509 510 switch (msg->hdr.cmd) { 511 case ESD_USB_CMD_CAN_RX: 512 if (msg->rx.net >= dev->net_count) { 513 dev_err(dev->udev->dev.parent, "format error\n"); 514 break; 515 } 516 517 esd_usb_rx_can_msg(dev->nets[msg->rx.net], msg); 518 break; 519 520 case ESD_USB_CMD_CAN_TX: 521 if (msg->txdone.net >= dev->net_count) { 522 dev_err(dev->udev->dev.parent, "format error\n"); 523 break; 524 } 525 526 esd_usb_tx_done_msg(dev->nets[msg->txdone.net], 527 msg); 528 break; 529 } 530 531 pos += msg->hdr.len * sizeof(u32); /* convert to # of bytes */ 532 533 if (pos > urb->actual_length) { 534 dev_err(dev->udev->dev.parent, "format error\n"); 535 break; 536 } 537 } 538 539 resubmit_urb: 540 usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1), 541 urb->transfer_buffer, ESD_USB_RX_BUFFER_SIZE, 542 esd_usb_read_bulk_callback, dev); 543 544 err = usb_submit_urb(urb, GFP_ATOMIC); 545 if (err == -ENODEV) { 546 for (i = 0; i < dev->net_count; i++) { 547 if (dev->nets[i]) 548 netif_device_detach(dev->nets[i]->netdev); 549 } 550 } else if (err) { 551 dev_err(dev->udev->dev.parent, 552 "failed resubmitting read bulk urb: %pe\n", ERR_PTR(err)); 553 } 554 } 555 556 /* callback for bulk IN urb */ 557 static void esd_usb_write_bulk_callback(struct urb *urb) 558 { 559 struct esd_tx_urb_context *context = urb->context; 560 struct esd_usb_net_priv *priv; 561 struct net_device *netdev; 562 size_t size = sizeof(union esd_usb_msg); 563 564 WARN_ON(!context); 565 566 priv = context->priv; 567 netdev = priv->netdev; 568 569 /* free up our allocated buffer */ 570 usb_free_coherent(urb->dev, size, 571 urb->transfer_buffer, urb->transfer_dma); 572 573 if (!netif_device_present(netdev)) 574 return; 575 576 if (urb->status) 577 netdev_info(netdev, "Tx URB aborted (%pe)\n", ERR_PTR(urb->status)); 578 579 netif_trans_update(netdev); 580 } 581 582 static ssize_t firmware_show(struct device *d, 583 struct device_attribute *attr, char *buf) 584 { 585 struct usb_interface *intf = to_usb_interface(d); 586 struct esd_usb *dev = usb_get_intfdata(intf); 587 588 return sprintf(buf, "%d.%d.%d\n", 589 (dev->version >> 12) & 0xf, 590 (dev->version >> 8) & 0xf, 591 dev->version & 0xff); 592 } 593 static DEVICE_ATTR_RO(firmware); 594 595 static ssize_t hardware_show(struct device *d, 596 struct device_attribute *attr, char *buf) 597 { 598 struct usb_interface *intf = to_usb_interface(d); 599 struct esd_usb *dev = usb_get_intfdata(intf); 600 601 return sprintf(buf, "%d.%d.%d\n", 602 (dev->version >> 28) & 0xf, 603 (dev->version >> 24) & 0xf, 604 (dev->version >> 16) & 0xff); 605 } 606 static DEVICE_ATTR_RO(hardware); 607 608 static ssize_t nets_show(struct device *d, 609 struct device_attribute *attr, char *buf) 610 { 611 struct usb_interface *intf = to_usb_interface(d); 612 struct esd_usb *dev = usb_get_intfdata(intf); 613 614 return sprintf(buf, "%d", dev->net_count); 615 } 616 static DEVICE_ATTR_RO(nets); 617 618 static int esd_usb_send_msg(struct esd_usb *dev, union esd_usb_msg *msg) 619 { 620 int actual_length; 621 622 return usb_bulk_msg(dev->udev, 623 usb_sndbulkpipe(dev->udev, 2), 624 msg, 625 msg->hdr.len * sizeof(u32), /* convert to # of bytes */ 626 &actual_length, 627 1000); 628 } 629 630 static int esd_usb_wait_msg(struct esd_usb *dev, 631 union esd_usb_msg *msg) 632 { 633 int actual_length; 634 635 return usb_bulk_msg(dev->udev, 636 usb_rcvbulkpipe(dev->udev, 1), 637 msg, 638 sizeof(*msg), 639 &actual_length, 640 1000); 641 } 642 643 static int esd_usb_setup_rx_urbs(struct esd_usb *dev) 644 { 645 int i, err = 0; 646 647 if (dev->rxinitdone) 648 return 0; 649 650 for (i = 0; i < ESD_USB_MAX_RX_URBS; i++) { 651 struct urb *urb = NULL; 652 u8 *buf = NULL; 653 dma_addr_t buf_dma; 654 655 /* create a URB, and a buffer for it */ 656 urb = usb_alloc_urb(0, GFP_KERNEL); 657 if (!urb) { 658 err = -ENOMEM; 659 break; 660 } 661 662 buf = usb_alloc_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, GFP_KERNEL, 663 &buf_dma); 664 if (!buf) { 665 dev_warn(dev->udev->dev.parent, 666 "No memory left for USB buffer\n"); 667 err = -ENOMEM; 668 goto freeurb; 669 } 670 671 urb->transfer_dma = buf_dma; 672 673 usb_fill_bulk_urb(urb, dev->udev, 674 usb_rcvbulkpipe(dev->udev, 1), 675 buf, ESD_USB_RX_BUFFER_SIZE, 676 esd_usb_read_bulk_callback, dev); 677 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 678 usb_anchor_urb(urb, &dev->rx_submitted); 679 680 err = usb_submit_urb(urb, GFP_KERNEL); 681 if (err) { 682 usb_unanchor_urb(urb); 683 usb_free_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, buf, 684 urb->transfer_dma); 685 goto freeurb; 686 } 687 688 dev->rxbuf[i] = buf; 689 dev->rxbuf_dma[i] = buf_dma; 690 691 freeurb: 692 /* Drop reference, USB core will take care of freeing it */ 693 usb_free_urb(urb); 694 if (err) 695 break; 696 } 697 698 /* Did we submit any URBs */ 699 if (i == 0) { 700 dev_err(dev->udev->dev.parent, "couldn't setup read URBs\n"); 701 return err; 702 } 703 704 /* Warn if we've couldn't transmit all the URBs */ 705 if (i < ESD_USB_MAX_RX_URBS) { 706 dev_warn(dev->udev->dev.parent, 707 "rx performance may be slow\n"); 708 } 709 710 dev->rxinitdone = 1; 711 return 0; 712 } 713 714 /* Start interface */ 715 static int esd_usb_start(struct esd_usb_net_priv *priv) 716 { 717 struct esd_usb *dev = priv->usb; 718 struct net_device *netdev = priv->netdev; 719 union esd_usb_msg *msg; 720 int err, i; 721 722 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 723 if (!msg) { 724 err = -ENOMEM; 725 goto out; 726 } 727 728 /* Enable all IDs 729 * The IDADD message takes up to 64 32 bit bitmasks (2048 bits). 730 * Each bit represents one 11 bit CAN identifier. A set bit 731 * enables reception of the corresponding CAN identifier. A cleared 732 * bit disabled this identifier. An additional bitmask value 733 * following the CAN 2.0A bits is used to enable reception of 734 * extended CAN frames. Only the LSB of this final mask is checked 735 * for the complete 29 bit ID range. The IDADD message also allows 736 * filter configuration for an ID subset. In this case you can add 737 * the number of the starting bitmask (0..64) to the filter.option 738 * field followed by only some bitmasks. 739 */ 740 msg->hdr.cmd = ESD_USB_CMD_IDADD; 741 msg->hdr.len = sizeof(struct esd_usb_id_filter_msg) / sizeof(u32); /* # of 32bit words */ 742 msg->filter.net = priv->index; 743 msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */ 744 for (i = 0; i < ESD_USB_MAX_ID_SEGMENT; i++) 745 msg->filter.mask[i] = cpu_to_le32(GENMASK(31, 0)); 746 /* enable 29bit extended IDs */ 747 msg->filter.mask[ESD_USB_MAX_ID_SEGMENT] = cpu_to_le32(BIT(0)); 748 749 err = esd_usb_send_msg(dev, msg); 750 if (err) 751 goto out; 752 753 err = esd_usb_setup_rx_urbs(dev); 754 if (err) 755 goto out; 756 757 priv->can.state = CAN_STATE_ERROR_ACTIVE; 758 759 out: 760 if (err == -ENODEV) 761 netif_device_detach(netdev); 762 if (err) 763 netdev_err(netdev, "couldn't start device: %pe\n", ERR_PTR(err)); 764 765 kfree(msg); 766 return err; 767 } 768 769 static void unlink_all_urbs(struct esd_usb *dev) 770 { 771 struct esd_usb_net_priv *priv; 772 int i, j; 773 774 usb_kill_anchored_urbs(&dev->rx_submitted); 775 776 for (i = 0; i < ESD_USB_MAX_RX_URBS; ++i) 777 usb_free_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, 778 dev->rxbuf[i], dev->rxbuf_dma[i]); 779 780 for (i = 0; i < dev->net_count; i++) { 781 priv = dev->nets[i]; 782 if (priv) { 783 usb_kill_anchored_urbs(&priv->tx_submitted); 784 atomic_set(&priv->active_tx_jobs, 0); 785 786 for (j = 0; j < ESD_USB_MAX_TX_URBS; j++) 787 priv->tx_contexts[j].echo_index = ESD_USB_MAX_TX_URBS; 788 } 789 } 790 } 791 792 static int esd_usb_open(struct net_device *netdev) 793 { 794 struct esd_usb_net_priv *priv = netdev_priv(netdev); 795 int err; 796 797 /* common open */ 798 err = open_candev(netdev); 799 if (err) 800 return err; 801 802 /* finally start device */ 803 err = esd_usb_start(priv); 804 if (err) { 805 close_candev(netdev); 806 return err; 807 } 808 809 netif_start_queue(netdev); 810 811 return 0; 812 } 813 814 static netdev_tx_t esd_usb_start_xmit(struct sk_buff *skb, 815 struct net_device *netdev) 816 { 817 struct esd_usb_net_priv *priv = netdev_priv(netdev); 818 struct esd_usb *dev = priv->usb; 819 struct esd_tx_urb_context *context = NULL; 820 struct net_device_stats *stats = &netdev->stats; 821 struct canfd_frame *cfd = (struct canfd_frame *)skb->data; 822 union esd_usb_msg *msg; 823 struct urb *urb; 824 u8 *buf; 825 int i, err; 826 int ret = NETDEV_TX_OK; 827 size_t size = sizeof(union esd_usb_msg); 828 829 if (can_dev_dropped_skb(netdev, skb)) 830 return NETDEV_TX_OK; 831 832 /* create a URB, and a buffer for it, and copy the data to the URB */ 833 urb = usb_alloc_urb(0, GFP_ATOMIC); 834 if (!urb) { 835 stats->tx_dropped++; 836 dev_kfree_skb(skb); 837 goto nourbmem; 838 } 839 840 buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, 841 &urb->transfer_dma); 842 if (!buf) { 843 netdev_err(netdev, "No memory left for USB buffer\n"); 844 stats->tx_dropped++; 845 dev_kfree_skb(skb); 846 goto nobufmem; 847 } 848 849 msg = (union esd_usb_msg *)buf; 850 851 /* minimal length as # of 32bit words */ 852 msg->hdr.len = offsetof(struct esd_usb_tx_msg, data) / sizeof(u32); 853 msg->hdr.cmd = ESD_USB_CMD_CAN_TX; 854 msg->tx.net = priv->index; 855 856 if (can_is_canfd_skb(skb)) { 857 msg->tx.dlc = can_fd_len2dlc(cfd->len); 858 msg->tx.dlc |= ESD_USB_FD; 859 860 if ((cfd->flags & CANFD_BRS) == 0) 861 msg->tx.dlc |= ESD_USB_NO_BRS; 862 } else { 863 msg->tx.dlc = can_get_cc_dlc((struct can_frame *)cfd, priv->can.ctrlmode); 864 865 if (cfd->can_id & CAN_RTR_FLAG) 866 msg->tx.dlc |= ESD_USB_RTR; 867 } 868 869 msg->tx.id = cpu_to_le32(cfd->can_id & CAN_ERR_MASK); 870 871 if (cfd->can_id & CAN_EFF_FLAG) 872 msg->tx.id |= cpu_to_le32(ESD_USB_EXTID); 873 874 memcpy(msg->tx.data_fd, cfd->data, cfd->len); 875 876 /* round up, then divide by 4 to add the payload length as # of 32bit words */ 877 msg->hdr.len += DIV_ROUND_UP(cfd->len, sizeof(u32)); 878 879 for (i = 0; i < ESD_USB_MAX_TX_URBS; i++) { 880 if (priv->tx_contexts[i].echo_index == ESD_USB_MAX_TX_URBS) { 881 context = &priv->tx_contexts[i]; 882 break; 883 } 884 } 885 886 /* This may never happen */ 887 if (!context) { 888 netdev_warn(netdev, "couldn't find free context\n"); 889 ret = NETDEV_TX_BUSY; 890 goto releasebuf; 891 } 892 893 context->priv = priv; 894 context->echo_index = i; 895 896 /* hnd must not be 0 - MSB is stripped in txdone handling */ 897 msg->tx.hnd = BIT(31) | i; /* returned in TX done message */ 898 899 usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf, 900 msg->hdr.len * sizeof(u32), /* convert to # of bytes */ 901 esd_usb_write_bulk_callback, context); 902 903 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 904 905 usb_anchor_urb(urb, &priv->tx_submitted); 906 907 can_put_echo_skb(skb, netdev, context->echo_index, 0); 908 909 atomic_inc(&priv->active_tx_jobs); 910 911 /* Slow down tx path */ 912 if (atomic_read(&priv->active_tx_jobs) >= ESD_USB_MAX_TX_URBS) 913 netif_stop_queue(netdev); 914 915 err = usb_submit_urb(urb, GFP_ATOMIC); 916 if (err) { 917 can_free_echo_skb(netdev, context->echo_index, NULL); 918 919 atomic_dec(&priv->active_tx_jobs); 920 usb_unanchor_urb(urb); 921 922 stats->tx_dropped++; 923 924 if (err == -ENODEV) 925 netif_device_detach(netdev); 926 else 927 netdev_warn(netdev, "failed tx_urb %pe\n", ERR_PTR(err)); 928 929 goto releasebuf; 930 } 931 932 netif_trans_update(netdev); 933 934 /* Release our reference to this URB, the USB core will eventually free 935 * it entirely. 936 */ 937 usb_free_urb(urb); 938 939 return NETDEV_TX_OK; 940 941 releasebuf: 942 usb_free_coherent(dev->udev, size, buf, urb->transfer_dma); 943 944 nobufmem: 945 usb_free_urb(urb); 946 947 nourbmem: 948 return ret; 949 } 950 951 /* Stop interface */ 952 static int esd_usb_stop(struct esd_usb_net_priv *priv) 953 { 954 union esd_usb_msg *msg; 955 int err; 956 int i; 957 958 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 959 if (!msg) 960 return -ENOMEM; 961 962 /* Disable all IDs (see esd_usb_start()) */ 963 msg->hdr.cmd = ESD_USB_CMD_IDADD; 964 msg->hdr.len = sizeof(struct esd_usb_id_filter_msg) / sizeof(u32);/* # of 32bit words */ 965 msg->filter.net = priv->index; 966 msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */ 967 for (i = 0; i <= ESD_USB_MAX_ID_SEGMENT; i++) 968 msg->filter.mask[i] = 0; 969 err = esd_usb_send_msg(priv->usb, msg); 970 if (err < 0) { 971 netdev_err(priv->netdev, "sending idadd message failed: %pe\n", ERR_PTR(err)); 972 goto bail; 973 } 974 975 /* set CAN controller to reset mode */ 976 msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */ 977 msg->hdr.cmd = ESD_USB_CMD_SETBAUD; 978 msg->setbaud.net = priv->index; 979 msg->setbaud.rsvd = 0; 980 msg->setbaud.baud = cpu_to_le32(ESD_USB_NO_BAUDRATE); 981 err = esd_usb_send_msg(priv->usb, msg); 982 if (err < 0) 983 netdev_err(priv->netdev, "sending setbaud message failed: %pe\n", ERR_PTR(err)); 984 985 bail: 986 kfree(msg); 987 988 return err; 989 } 990 991 static int esd_usb_close(struct net_device *netdev) 992 { 993 struct esd_usb_net_priv *priv = netdev_priv(netdev); 994 int err = 0; 995 996 if (!priv->usb->in_usb_disconnect) { 997 /* It's moot to try this in usb_disconnect()! */ 998 err = esd_usb_stop(priv); 999 } 1000 1001 priv->can.state = CAN_STATE_STOPPED; 1002 1003 netif_stop_queue(netdev); 1004 1005 close_candev(netdev); 1006 1007 return err; 1008 } 1009 1010 static const struct net_device_ops esd_usb_netdev_ops = { 1011 .ndo_open = esd_usb_open, 1012 .ndo_stop = esd_usb_close, 1013 .ndo_start_xmit = esd_usb_start_xmit, 1014 }; 1015 1016 static const struct ethtool_ops esd_usb_ethtool_ops = { 1017 .get_ts_info = ethtool_op_get_ts_info, 1018 }; 1019 1020 static const struct can_bittiming_const esd_usb_2_bittiming_const = { 1021 .name = "esd_usb_2", 1022 .tseg1_min = 1, 1023 .tseg1_max = 16, 1024 .tseg2_min = 1, 1025 .tseg2_max = 8, 1026 .sjw_max = 4, 1027 .brp_min = 1, 1028 .brp_max = 1024, 1029 .brp_inc = 1, 1030 }; 1031 1032 static int esd_usb_2_set_bittiming(struct net_device *netdev) 1033 { 1034 const struct can_bittiming_const *btc = &esd_usb_2_bittiming_const; 1035 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1036 struct can_bittiming *bt = &priv->can.bittiming; 1037 union esd_usb_msg *msg; 1038 int err; 1039 u32 canbtr; 1040 int sjw_shift; 1041 1042 canbtr = ESD_USB_UBR; 1043 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1044 canbtr |= ESD_USB_LOM; 1045 1046 canbtr |= (bt->brp - 1) & (btc->brp_max - 1); 1047 1048 if (le16_to_cpu(priv->usb->udev->descriptor.idProduct) == 1049 ESD_USB_CANUSBM_PRODUCT_ID) 1050 sjw_shift = ESD_USB_M_SJW_SHIFT; 1051 else 1052 sjw_shift = ESD_USB_2_SJW_SHIFT; 1053 1054 canbtr |= ((bt->sjw - 1) & (btc->sjw_max - 1)) 1055 << sjw_shift; 1056 canbtr |= ((bt->prop_seg + bt->phase_seg1 - 1) 1057 & (btc->tseg1_max - 1)) 1058 << ESD_USB_2_TSEG1_SHIFT; 1059 canbtr |= ((bt->phase_seg2 - 1) & (btc->tseg2_max - 1)) 1060 << ESD_USB_2_TSEG2_SHIFT; 1061 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 1062 canbtr |= ESD_USB_TRIPLE_SAMPLES; 1063 1064 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1065 if (!msg) 1066 return -ENOMEM; 1067 1068 msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */ 1069 msg->hdr.cmd = ESD_USB_CMD_SETBAUD; 1070 msg->setbaud.net = priv->index; 1071 msg->setbaud.rsvd = 0; 1072 msg->setbaud.baud = cpu_to_le32(canbtr); 1073 1074 netdev_dbg(netdev, "setting BTR=%#x\n", canbtr); 1075 1076 err = esd_usb_send_msg(priv->usb, msg); 1077 1078 kfree(msg); 1079 return err; 1080 } 1081 1082 /* Nominal bittiming constants, see 1083 * Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022 1084 * 48.6.8 MCAN Nominal Bit Timing and Prescaler Register 1085 */ 1086 static const struct can_bittiming_const esd_usb_3_nom_bittiming_const = { 1087 .name = "esd_usb_3", 1088 .tseg1_min = 2, 1089 .tseg1_max = 256, 1090 .tseg2_min = 2, 1091 .tseg2_max = 128, 1092 .sjw_max = 128, 1093 .brp_min = 1, 1094 .brp_max = 512, 1095 .brp_inc = 1, 1096 }; 1097 1098 /* Data bittiming constants, see 1099 * Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022 1100 * 48.6.4 MCAN Data Bit Timing and Prescaler Register 1101 */ 1102 static const struct can_bittiming_const esd_usb_3_data_bittiming_const = { 1103 .name = "esd_usb_3", 1104 .tseg1_min = 2, 1105 .tseg1_max = 32, 1106 .tseg2_min = 1, 1107 .tseg2_max = 16, 1108 .sjw_max = 8, 1109 .brp_min = 1, 1110 .brp_max = 32, 1111 .brp_inc = 1, 1112 }; 1113 1114 static int esd_usb_3_set_bittiming(struct net_device *netdev) 1115 { 1116 const struct can_bittiming_const *nom_btc = &esd_usb_3_nom_bittiming_const; 1117 const struct can_bittiming_const *data_btc = &esd_usb_3_data_bittiming_const; 1118 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1119 struct can_bittiming *nom_bt = &priv->can.bittiming; 1120 struct can_bittiming *data_bt = &priv->can.fd.data_bittiming; 1121 struct esd_usb_3_set_baudrate_msg_x *baud_x; 1122 union esd_usb_msg *msg; 1123 u16 flags = 0; 1124 int err; 1125 1126 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1127 if (!msg) 1128 return -ENOMEM; 1129 1130 baud_x = &msg->setbaud_x; 1131 1132 /* Canonical is the most reasonable mode for SocketCAN on CAN-USB/3 ... */ 1133 baud_x->mode = cpu_to_le16(ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL); 1134 1135 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1136 flags |= ESD_USB_3_BAUDRATE_FLAG_LOM; 1137 1138 baud_x->nom.brp = cpu_to_le16(nom_bt->brp & (nom_btc->brp_max - 1)); 1139 baud_x->nom.sjw = cpu_to_le16(nom_bt->sjw & (nom_btc->sjw_max - 1)); 1140 baud_x->nom.tseg1 = cpu_to_le16((nom_bt->prop_seg + nom_bt->phase_seg1) 1141 & (nom_btc->tseg1_max - 1)); 1142 baud_x->nom.tseg2 = cpu_to_le16(nom_bt->phase_seg2 & (nom_btc->tseg2_max - 1)); 1143 1144 if (priv->can.ctrlmode & CAN_CTRLMODE_FD) { 1145 baud_x->data.brp = cpu_to_le16(data_bt->brp & (data_btc->brp_max - 1)); 1146 baud_x->data.sjw = cpu_to_le16(data_bt->sjw & (data_btc->sjw_max - 1)); 1147 baud_x->data.tseg1 = cpu_to_le16((data_bt->prop_seg + data_bt->phase_seg1) 1148 & (data_btc->tseg1_max - 1)); 1149 baud_x->data.tseg2 = cpu_to_le16(data_bt->phase_seg2 & (data_btc->tseg2_max - 1)); 1150 flags |= ESD_USB_3_BAUDRATE_FLAG_FD; 1151 } 1152 1153 /* Currently this driver only supports the automatic TDC mode */ 1154 baud_x->tdc.tdc_mode = ESD_USB_3_TDC_MODE_AUTO; 1155 baud_x->tdc.ssp_offset = 0; 1156 baud_x->tdc.ssp_shift = 0; 1157 baud_x->tdc.tdc_filter = 0; 1158 1159 baud_x->flags = cpu_to_le16(flags); 1160 baud_x->net = priv->index; 1161 baud_x->rsvd = 0; 1162 1163 /* set len as # of 32bit words */ 1164 msg->hdr.len = sizeof(struct esd_usb_3_set_baudrate_msg_x) / sizeof(u32); 1165 msg->hdr.cmd = ESD_USB_CMD_SETBAUD; 1166 1167 netdev_dbg(netdev, 1168 "ctrlmode=%#x/%#x, esd-net=%u, esd-mode=%#x, esd-flags=%#x\n", 1169 priv->can.ctrlmode, priv->can.ctrlmode_supported, 1170 priv->index, le16_to_cpu(baud_x->mode), flags); 1171 1172 err = esd_usb_send_msg(priv->usb, msg); 1173 1174 kfree(msg); 1175 return err; 1176 } 1177 1178 static int esd_usb_get_berr_counter(const struct net_device *netdev, 1179 struct can_berr_counter *bec) 1180 { 1181 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1182 1183 bec->txerr = priv->bec.txerr; 1184 bec->rxerr = priv->bec.rxerr; 1185 1186 return 0; 1187 } 1188 1189 static int esd_usb_set_mode(struct net_device *netdev, enum can_mode mode) 1190 { 1191 switch (mode) { 1192 case CAN_MODE_START: 1193 netif_wake_queue(netdev); 1194 break; 1195 1196 default: 1197 return -EOPNOTSUPP; 1198 } 1199 1200 return 0; 1201 } 1202 1203 static int esd_usb_probe_one_net(struct usb_interface *intf, int index) 1204 { 1205 struct esd_usb *dev = usb_get_intfdata(intf); 1206 struct net_device *netdev; 1207 struct esd_usb_net_priv *priv; 1208 int err = 0; 1209 int i; 1210 1211 netdev = alloc_candev(sizeof(*priv), ESD_USB_MAX_TX_URBS); 1212 if (!netdev) { 1213 dev_err(&intf->dev, "couldn't alloc candev\n"); 1214 err = -ENOMEM; 1215 goto done; 1216 } 1217 1218 priv = netdev_priv(netdev); 1219 1220 init_usb_anchor(&priv->tx_submitted); 1221 atomic_set(&priv->active_tx_jobs, 0); 1222 1223 for (i = 0; i < ESD_USB_MAX_TX_URBS; i++) 1224 priv->tx_contexts[i].echo_index = ESD_USB_MAX_TX_URBS; 1225 1226 priv->usb = dev; 1227 priv->netdev = netdev; 1228 priv->index = index; 1229 1230 priv->can.state = CAN_STATE_STOPPED; 1231 priv->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY | 1232 CAN_CTRLMODE_CC_LEN8_DLC | 1233 CAN_CTRLMODE_BERR_REPORTING; 1234 1235 switch (le16_to_cpu(dev->udev->descriptor.idProduct)) { 1236 case ESD_USB_CANUSB3_PRODUCT_ID: 1237 priv->can.clock.freq = ESD_USB_3_CAN_CLOCK; 1238 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD; 1239 priv->can.bittiming_const = &esd_usb_3_nom_bittiming_const; 1240 priv->can.fd.data_bittiming_const = &esd_usb_3_data_bittiming_const; 1241 priv->can.do_set_bittiming = esd_usb_3_set_bittiming; 1242 priv->can.fd.do_set_data_bittiming = esd_usb_3_set_bittiming; 1243 break; 1244 1245 case ESD_USB_CANUSBM_PRODUCT_ID: 1246 priv->can.clock.freq = ESD_USB_M_CAN_CLOCK; 1247 priv->can.bittiming_const = &esd_usb_2_bittiming_const; 1248 priv->can.do_set_bittiming = esd_usb_2_set_bittiming; 1249 break; 1250 1251 case ESD_USB_CANUSB2_PRODUCT_ID: 1252 default: 1253 priv->can.clock.freq = ESD_USB_2_CAN_CLOCK; 1254 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 1255 priv->can.bittiming_const = &esd_usb_2_bittiming_const; 1256 priv->can.do_set_bittiming = esd_usb_2_set_bittiming; 1257 break; 1258 } 1259 1260 priv->can.do_set_mode = esd_usb_set_mode; 1261 priv->can.do_get_berr_counter = esd_usb_get_berr_counter; 1262 1263 netdev->flags |= IFF_ECHO; /* we support local echo */ 1264 1265 netdev->netdev_ops = &esd_usb_netdev_ops; 1266 netdev->ethtool_ops = &esd_usb_ethtool_ops; 1267 1268 SET_NETDEV_DEV(netdev, &intf->dev); 1269 netdev->dev_id = index; 1270 1271 err = register_candev(netdev); 1272 if (err) { 1273 dev_err(&intf->dev, "couldn't register CAN device: %pe\n", ERR_PTR(err)); 1274 free_candev(netdev); 1275 err = -ENOMEM; 1276 goto done; 1277 } 1278 1279 dev->nets[index] = priv; 1280 netdev_info(netdev, "registered\n"); 1281 1282 done: 1283 return err; 1284 } 1285 1286 /* probe function for new USB devices 1287 * 1288 * check version information and number of available 1289 * CAN interfaces 1290 */ 1291 static int esd_usb_probe(struct usb_interface *intf, 1292 const struct usb_device_id *id) 1293 { 1294 struct esd_usb *dev; 1295 union esd_usb_msg *msg; 1296 int i, err; 1297 1298 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1299 if (!dev) { 1300 err = -ENOMEM; 1301 goto done; 1302 } 1303 1304 dev->udev = interface_to_usbdev(intf); 1305 1306 init_usb_anchor(&dev->rx_submitted); 1307 1308 usb_set_intfdata(intf, dev); 1309 1310 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1311 if (!msg) { 1312 err = -ENOMEM; 1313 goto free_msg; 1314 } 1315 1316 /* query number of CAN interfaces (nets) */ 1317 msg->hdr.cmd = ESD_USB_CMD_VERSION; 1318 msg->hdr.len = sizeof(struct esd_usb_version_msg) / sizeof(u32); /* # of 32bit words */ 1319 msg->version.rsvd = 0; 1320 msg->version.flags = 0; 1321 msg->version.drv_version = 0; 1322 1323 err = esd_usb_send_msg(dev, msg); 1324 if (err < 0) { 1325 dev_err(&intf->dev, "sending version message failed\n"); 1326 goto free_msg; 1327 } 1328 1329 err = esd_usb_wait_msg(dev, msg); 1330 if (err < 0) { 1331 dev_err(&intf->dev, "no version message answer\n"); 1332 goto free_msg; 1333 } 1334 1335 dev->net_count = (int)msg->version_reply.nets; 1336 dev->version = le32_to_cpu(msg->version_reply.version); 1337 1338 if (device_create_file(&intf->dev, &dev_attr_firmware)) 1339 dev_err(&intf->dev, 1340 "Couldn't create device file for firmware\n"); 1341 1342 if (device_create_file(&intf->dev, &dev_attr_hardware)) 1343 dev_err(&intf->dev, 1344 "Couldn't create device file for hardware\n"); 1345 1346 if (device_create_file(&intf->dev, &dev_attr_nets)) 1347 dev_err(&intf->dev, 1348 "Couldn't create device file for nets\n"); 1349 1350 /* do per device probing */ 1351 for (i = 0; i < dev->net_count; i++) 1352 esd_usb_probe_one_net(intf, i); 1353 1354 free_msg: 1355 kfree(msg); 1356 if (err) 1357 kfree(dev); 1358 done: 1359 return err; 1360 } 1361 1362 /* called by the usb core when the device is removed from the system */ 1363 static void esd_usb_disconnect(struct usb_interface *intf) 1364 { 1365 struct esd_usb *dev = usb_get_intfdata(intf); 1366 struct net_device *netdev; 1367 int i; 1368 1369 device_remove_file(&intf->dev, &dev_attr_firmware); 1370 device_remove_file(&intf->dev, &dev_attr_hardware); 1371 device_remove_file(&intf->dev, &dev_attr_nets); 1372 1373 usb_set_intfdata(intf, NULL); 1374 1375 if (dev) { 1376 dev->in_usb_disconnect = 1; 1377 for (i = 0; i < dev->net_count; i++) { 1378 if (dev->nets[i]) { 1379 netdev = dev->nets[i]->netdev; 1380 netdev_info(netdev, "unregister\n"); 1381 unregister_netdev(netdev); 1382 free_candev(netdev); 1383 } 1384 } 1385 unlink_all_urbs(dev); 1386 kfree(dev); 1387 } 1388 } 1389 1390 /* usb specific object needed to register this driver with the usb subsystem */ 1391 static struct usb_driver esd_usb_driver = { 1392 .name = KBUILD_MODNAME, 1393 .probe = esd_usb_probe, 1394 .disconnect = esd_usb_disconnect, 1395 .id_table = esd_usb_table, 1396 }; 1397 1398 module_usb_driver(esd_usb_driver); 1399