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 usb_anchor_urb(urb, &dev->rx_submitted); 545 546 err = usb_submit_urb(urb, GFP_ATOMIC); 547 if (!err) 548 return; 549 550 usb_unanchor_urb(urb); 551 552 if (err == -ENODEV) { 553 for (i = 0; i < dev->net_count; i++) { 554 if (dev->nets[i]) 555 netif_device_detach(dev->nets[i]->netdev); 556 } 557 } else { 558 dev_err(dev->udev->dev.parent, 559 "failed resubmitting read bulk urb: %pe\n", ERR_PTR(err)); 560 } 561 } 562 563 /* callback for bulk IN urb */ 564 static void esd_usb_write_bulk_callback(struct urb *urb) 565 { 566 struct esd_tx_urb_context *context = urb->context; 567 struct esd_usb_net_priv *priv; 568 struct net_device *netdev; 569 size_t size = sizeof(union esd_usb_msg); 570 571 WARN_ON(!context); 572 573 priv = context->priv; 574 netdev = priv->netdev; 575 576 /* free up our allocated buffer */ 577 usb_free_coherent(urb->dev, size, 578 urb->transfer_buffer, urb->transfer_dma); 579 580 if (!netif_device_present(netdev)) 581 return; 582 583 if (urb->status) 584 netdev_info(netdev, "Tx URB aborted (%pe)\n", ERR_PTR(urb->status)); 585 586 netif_trans_update(netdev); 587 } 588 589 static ssize_t firmware_show(struct device *d, 590 struct device_attribute *attr, char *buf) 591 { 592 struct usb_interface *intf = to_usb_interface(d); 593 struct esd_usb *dev = usb_get_intfdata(intf); 594 595 return sprintf(buf, "%d.%d.%d\n", 596 (dev->version >> 12) & 0xf, 597 (dev->version >> 8) & 0xf, 598 dev->version & 0xff); 599 } 600 static DEVICE_ATTR_RO(firmware); 601 602 static ssize_t hardware_show(struct device *d, 603 struct device_attribute *attr, char *buf) 604 { 605 struct usb_interface *intf = to_usb_interface(d); 606 struct esd_usb *dev = usb_get_intfdata(intf); 607 608 return sprintf(buf, "%d.%d.%d\n", 609 (dev->version >> 28) & 0xf, 610 (dev->version >> 24) & 0xf, 611 (dev->version >> 16) & 0xff); 612 } 613 static DEVICE_ATTR_RO(hardware); 614 615 static ssize_t nets_show(struct device *d, 616 struct device_attribute *attr, char *buf) 617 { 618 struct usb_interface *intf = to_usb_interface(d); 619 struct esd_usb *dev = usb_get_intfdata(intf); 620 621 return sprintf(buf, "%d", dev->net_count); 622 } 623 static DEVICE_ATTR_RO(nets); 624 625 static int esd_usb_send_msg(struct esd_usb *dev, union esd_usb_msg *msg) 626 { 627 int actual_length; 628 629 return usb_bulk_msg(dev->udev, 630 usb_sndbulkpipe(dev->udev, 2), 631 msg, 632 msg->hdr.len * sizeof(u32), /* convert to # of bytes */ 633 &actual_length, 634 1000); 635 } 636 637 static int esd_usb_wait_msg(struct esd_usb *dev, 638 union esd_usb_msg *msg) 639 { 640 int actual_length; 641 642 return usb_bulk_msg(dev->udev, 643 usb_rcvbulkpipe(dev->udev, 1), 644 msg, 645 sizeof(*msg), 646 &actual_length, 647 1000); 648 } 649 650 static int esd_usb_setup_rx_urbs(struct esd_usb *dev) 651 { 652 int i, err = 0; 653 654 if (dev->rxinitdone) 655 return 0; 656 657 for (i = 0; i < ESD_USB_MAX_RX_URBS; i++) { 658 struct urb *urb = NULL; 659 u8 *buf = NULL; 660 dma_addr_t buf_dma; 661 662 /* create a URB, and a buffer for it */ 663 urb = usb_alloc_urb(0, GFP_KERNEL); 664 if (!urb) { 665 err = -ENOMEM; 666 break; 667 } 668 669 buf = usb_alloc_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, GFP_KERNEL, 670 &buf_dma); 671 if (!buf) { 672 dev_warn(dev->udev->dev.parent, 673 "No memory left for USB buffer\n"); 674 err = -ENOMEM; 675 goto freeurb; 676 } 677 678 urb->transfer_dma = buf_dma; 679 680 usb_fill_bulk_urb(urb, dev->udev, 681 usb_rcvbulkpipe(dev->udev, 1), 682 buf, ESD_USB_RX_BUFFER_SIZE, 683 esd_usb_read_bulk_callback, dev); 684 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 685 usb_anchor_urb(urb, &dev->rx_submitted); 686 687 err = usb_submit_urb(urb, GFP_KERNEL); 688 if (err) { 689 usb_unanchor_urb(urb); 690 usb_free_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, buf, 691 urb->transfer_dma); 692 goto freeurb; 693 } 694 695 dev->rxbuf[i] = buf; 696 dev->rxbuf_dma[i] = buf_dma; 697 698 freeurb: 699 /* Drop reference, USB core will take care of freeing it */ 700 usb_free_urb(urb); 701 if (err) 702 break; 703 } 704 705 /* Did we submit any URBs */ 706 if (i == 0) { 707 dev_err(dev->udev->dev.parent, "couldn't setup read URBs\n"); 708 return err; 709 } 710 711 /* Warn if we've couldn't transmit all the URBs */ 712 if (i < ESD_USB_MAX_RX_URBS) { 713 dev_warn(dev->udev->dev.parent, 714 "rx performance may be slow\n"); 715 } 716 717 dev->rxinitdone = 1; 718 return 0; 719 } 720 721 /* Start interface */ 722 static int esd_usb_start(struct esd_usb_net_priv *priv) 723 { 724 struct esd_usb *dev = priv->usb; 725 struct net_device *netdev = priv->netdev; 726 union esd_usb_msg *msg; 727 int err, i; 728 729 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 730 if (!msg) { 731 err = -ENOMEM; 732 goto out; 733 } 734 735 /* Enable all IDs 736 * The IDADD message takes up to 64 32 bit bitmasks (2048 bits). 737 * Each bit represents one 11 bit CAN identifier. A set bit 738 * enables reception of the corresponding CAN identifier. A cleared 739 * bit disabled this identifier. An additional bitmask value 740 * following the CAN 2.0A bits is used to enable reception of 741 * extended CAN frames. Only the LSB of this final mask is checked 742 * for the complete 29 bit ID range. The IDADD message also allows 743 * filter configuration for an ID subset. In this case you can add 744 * the number of the starting bitmask (0..64) to the filter.option 745 * field followed by only some bitmasks. 746 */ 747 msg->hdr.cmd = ESD_USB_CMD_IDADD; 748 msg->hdr.len = sizeof(struct esd_usb_id_filter_msg) / sizeof(u32); /* # of 32bit words */ 749 msg->filter.net = priv->index; 750 msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */ 751 for (i = 0; i < ESD_USB_MAX_ID_SEGMENT; i++) 752 msg->filter.mask[i] = cpu_to_le32(GENMASK(31, 0)); 753 /* enable 29bit extended IDs */ 754 msg->filter.mask[ESD_USB_MAX_ID_SEGMENT] = cpu_to_le32(BIT(0)); 755 756 err = esd_usb_send_msg(dev, msg); 757 if (err) 758 goto out; 759 760 err = esd_usb_setup_rx_urbs(dev); 761 if (err) 762 goto out; 763 764 priv->can.state = CAN_STATE_ERROR_ACTIVE; 765 766 out: 767 if (err == -ENODEV) 768 netif_device_detach(netdev); 769 if (err) 770 netdev_err(netdev, "couldn't start device: %pe\n", ERR_PTR(err)); 771 772 kfree(msg); 773 return err; 774 } 775 776 static void unlink_all_urbs(struct esd_usb *dev) 777 { 778 struct esd_usb_net_priv *priv; 779 int i, j; 780 781 usb_kill_anchored_urbs(&dev->rx_submitted); 782 783 for (i = 0; i < ESD_USB_MAX_RX_URBS; ++i) 784 usb_free_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, 785 dev->rxbuf[i], dev->rxbuf_dma[i]); 786 787 for (i = 0; i < dev->net_count; i++) { 788 priv = dev->nets[i]; 789 if (priv) { 790 usb_kill_anchored_urbs(&priv->tx_submitted); 791 atomic_set(&priv->active_tx_jobs, 0); 792 793 for (j = 0; j < ESD_USB_MAX_TX_URBS; j++) 794 priv->tx_contexts[j].echo_index = ESD_USB_MAX_TX_URBS; 795 } 796 } 797 } 798 799 static int esd_usb_open(struct net_device *netdev) 800 { 801 struct esd_usb_net_priv *priv = netdev_priv(netdev); 802 int err; 803 804 /* common open */ 805 err = open_candev(netdev); 806 if (err) 807 return err; 808 809 /* finally start device */ 810 err = esd_usb_start(priv); 811 if (err) { 812 close_candev(netdev); 813 return err; 814 } 815 816 netif_start_queue(netdev); 817 818 return 0; 819 } 820 821 static netdev_tx_t esd_usb_start_xmit(struct sk_buff *skb, 822 struct net_device *netdev) 823 { 824 struct esd_usb_net_priv *priv = netdev_priv(netdev); 825 struct esd_usb *dev = priv->usb; 826 struct esd_tx_urb_context *context = NULL; 827 struct net_device_stats *stats = &netdev->stats; 828 struct canfd_frame *cfd = (struct canfd_frame *)skb->data; 829 union esd_usb_msg *msg; 830 struct urb *urb; 831 u8 *buf; 832 int i, err; 833 int ret = NETDEV_TX_OK; 834 size_t size = sizeof(union esd_usb_msg); 835 836 if (can_dev_dropped_skb(netdev, skb)) 837 return NETDEV_TX_OK; 838 839 /* create a URB, and a buffer for it, and copy the data to the URB */ 840 urb = usb_alloc_urb(0, GFP_ATOMIC); 841 if (!urb) { 842 stats->tx_dropped++; 843 dev_kfree_skb(skb); 844 goto nourbmem; 845 } 846 847 buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, 848 &urb->transfer_dma); 849 if (!buf) { 850 netdev_err(netdev, "No memory left for USB buffer\n"); 851 stats->tx_dropped++; 852 dev_kfree_skb(skb); 853 goto nobufmem; 854 } 855 856 msg = (union esd_usb_msg *)buf; 857 858 /* minimal length as # of 32bit words */ 859 msg->hdr.len = offsetof(struct esd_usb_tx_msg, data) / sizeof(u32); 860 msg->hdr.cmd = ESD_USB_CMD_CAN_TX; 861 msg->tx.net = priv->index; 862 863 if (can_is_canfd_skb(skb)) { 864 msg->tx.dlc = can_fd_len2dlc(cfd->len); 865 msg->tx.dlc |= ESD_USB_FD; 866 867 if ((cfd->flags & CANFD_BRS) == 0) 868 msg->tx.dlc |= ESD_USB_NO_BRS; 869 } else { 870 msg->tx.dlc = can_get_cc_dlc((struct can_frame *)cfd, priv->can.ctrlmode); 871 872 if (cfd->can_id & CAN_RTR_FLAG) 873 msg->tx.dlc |= ESD_USB_RTR; 874 } 875 876 msg->tx.id = cpu_to_le32(cfd->can_id & CAN_ERR_MASK); 877 878 if (cfd->can_id & CAN_EFF_FLAG) 879 msg->tx.id |= cpu_to_le32(ESD_USB_EXTID); 880 881 memcpy(msg->tx.data_fd, cfd->data, cfd->len); 882 883 /* round up, then divide by 4 to add the payload length as # of 32bit words */ 884 msg->hdr.len += DIV_ROUND_UP(cfd->len, sizeof(u32)); 885 886 for (i = 0; i < ESD_USB_MAX_TX_URBS; i++) { 887 if (priv->tx_contexts[i].echo_index == ESD_USB_MAX_TX_URBS) { 888 context = &priv->tx_contexts[i]; 889 break; 890 } 891 } 892 893 /* This may never happen */ 894 if (!context) { 895 netdev_warn(netdev, "couldn't find free context\n"); 896 ret = NETDEV_TX_BUSY; 897 goto releasebuf; 898 } 899 900 context->priv = priv; 901 context->echo_index = i; 902 903 /* hnd must not be 0 - MSB is stripped in txdone handling */ 904 msg->tx.hnd = BIT(31) | i; /* returned in TX done message */ 905 906 usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf, 907 msg->hdr.len * sizeof(u32), /* convert to # of bytes */ 908 esd_usb_write_bulk_callback, context); 909 910 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 911 912 usb_anchor_urb(urb, &priv->tx_submitted); 913 914 can_put_echo_skb(skb, netdev, context->echo_index, 0); 915 916 atomic_inc(&priv->active_tx_jobs); 917 918 /* Slow down tx path */ 919 if (atomic_read(&priv->active_tx_jobs) >= ESD_USB_MAX_TX_URBS) 920 netif_stop_queue(netdev); 921 922 err = usb_submit_urb(urb, GFP_ATOMIC); 923 if (err) { 924 can_free_echo_skb(netdev, context->echo_index, NULL); 925 926 atomic_dec(&priv->active_tx_jobs); 927 usb_unanchor_urb(urb); 928 929 stats->tx_dropped++; 930 931 if (err == -ENODEV) 932 netif_device_detach(netdev); 933 else 934 netdev_warn(netdev, "failed tx_urb %pe\n", ERR_PTR(err)); 935 936 goto releasebuf; 937 } 938 939 netif_trans_update(netdev); 940 941 /* Release our reference to this URB, the USB core will eventually free 942 * it entirely. 943 */ 944 usb_free_urb(urb); 945 946 return NETDEV_TX_OK; 947 948 releasebuf: 949 usb_free_coherent(dev->udev, size, buf, urb->transfer_dma); 950 951 nobufmem: 952 usb_free_urb(urb); 953 954 nourbmem: 955 return ret; 956 } 957 958 /* Stop interface */ 959 static int esd_usb_stop(struct esd_usb_net_priv *priv) 960 { 961 union esd_usb_msg *msg; 962 int err; 963 int i; 964 965 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 966 if (!msg) 967 return -ENOMEM; 968 969 /* Disable all IDs (see esd_usb_start()) */ 970 msg->hdr.cmd = ESD_USB_CMD_IDADD; 971 msg->hdr.len = sizeof(struct esd_usb_id_filter_msg) / sizeof(u32);/* # of 32bit words */ 972 msg->filter.net = priv->index; 973 msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */ 974 for (i = 0; i <= ESD_USB_MAX_ID_SEGMENT; i++) 975 msg->filter.mask[i] = 0; 976 err = esd_usb_send_msg(priv->usb, msg); 977 if (err < 0) { 978 netdev_err(priv->netdev, "sending idadd message failed: %pe\n", ERR_PTR(err)); 979 goto bail; 980 } 981 982 /* set CAN controller to reset mode */ 983 msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */ 984 msg->hdr.cmd = ESD_USB_CMD_SETBAUD; 985 msg->setbaud.net = priv->index; 986 msg->setbaud.rsvd = 0; 987 msg->setbaud.baud = cpu_to_le32(ESD_USB_NO_BAUDRATE); 988 err = esd_usb_send_msg(priv->usb, msg); 989 if (err < 0) 990 netdev_err(priv->netdev, "sending setbaud message failed: %pe\n", ERR_PTR(err)); 991 992 bail: 993 kfree(msg); 994 995 return err; 996 } 997 998 static int esd_usb_close(struct net_device *netdev) 999 { 1000 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1001 int err = 0; 1002 1003 if (!priv->usb->in_usb_disconnect) { 1004 /* It's moot to try this in usb_disconnect()! */ 1005 err = esd_usb_stop(priv); 1006 } 1007 1008 priv->can.state = CAN_STATE_STOPPED; 1009 1010 netif_stop_queue(netdev); 1011 1012 close_candev(netdev); 1013 1014 return err; 1015 } 1016 1017 static const struct net_device_ops esd_usb_netdev_ops = { 1018 .ndo_open = esd_usb_open, 1019 .ndo_stop = esd_usb_close, 1020 .ndo_start_xmit = esd_usb_start_xmit, 1021 }; 1022 1023 static const struct ethtool_ops esd_usb_ethtool_ops = { 1024 .get_ts_info = ethtool_op_get_ts_info, 1025 }; 1026 1027 static const struct can_bittiming_const esd_usb_2_bittiming_const = { 1028 .name = "esd_usb_2", 1029 .tseg1_min = 1, 1030 .tseg1_max = 16, 1031 .tseg2_min = 1, 1032 .tseg2_max = 8, 1033 .sjw_max = 4, 1034 .brp_min = 1, 1035 .brp_max = 1024, 1036 .brp_inc = 1, 1037 }; 1038 1039 static int esd_usb_2_set_bittiming(struct net_device *netdev) 1040 { 1041 const struct can_bittiming_const *btc = &esd_usb_2_bittiming_const; 1042 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1043 struct can_bittiming *bt = &priv->can.bittiming; 1044 union esd_usb_msg *msg; 1045 int err; 1046 u32 canbtr; 1047 int sjw_shift; 1048 1049 canbtr = ESD_USB_UBR; 1050 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1051 canbtr |= ESD_USB_LOM; 1052 1053 canbtr |= (bt->brp - 1) & (btc->brp_max - 1); 1054 1055 if (le16_to_cpu(priv->usb->udev->descriptor.idProduct) == 1056 ESD_USB_CANUSBM_PRODUCT_ID) 1057 sjw_shift = ESD_USB_M_SJW_SHIFT; 1058 else 1059 sjw_shift = ESD_USB_2_SJW_SHIFT; 1060 1061 canbtr |= ((bt->sjw - 1) & (btc->sjw_max - 1)) 1062 << sjw_shift; 1063 canbtr |= ((bt->prop_seg + bt->phase_seg1 - 1) 1064 & (btc->tseg1_max - 1)) 1065 << ESD_USB_2_TSEG1_SHIFT; 1066 canbtr |= ((bt->phase_seg2 - 1) & (btc->tseg2_max - 1)) 1067 << ESD_USB_2_TSEG2_SHIFT; 1068 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 1069 canbtr |= ESD_USB_TRIPLE_SAMPLES; 1070 1071 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1072 if (!msg) 1073 return -ENOMEM; 1074 1075 msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */ 1076 msg->hdr.cmd = ESD_USB_CMD_SETBAUD; 1077 msg->setbaud.net = priv->index; 1078 msg->setbaud.rsvd = 0; 1079 msg->setbaud.baud = cpu_to_le32(canbtr); 1080 1081 netdev_dbg(netdev, "setting BTR=%#x\n", canbtr); 1082 1083 err = esd_usb_send_msg(priv->usb, msg); 1084 1085 kfree(msg); 1086 return err; 1087 } 1088 1089 /* Nominal bittiming constants, see 1090 * Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022 1091 * 48.6.8 MCAN Nominal Bit Timing and Prescaler Register 1092 */ 1093 static const struct can_bittiming_const esd_usb_3_nom_bittiming_const = { 1094 .name = "esd_usb_3", 1095 .tseg1_min = 2, 1096 .tseg1_max = 256, 1097 .tseg2_min = 2, 1098 .tseg2_max = 128, 1099 .sjw_max = 128, 1100 .brp_min = 1, 1101 .brp_max = 512, 1102 .brp_inc = 1, 1103 }; 1104 1105 /* Data bittiming constants, see 1106 * Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022 1107 * 48.6.4 MCAN Data Bit Timing and Prescaler Register 1108 */ 1109 static const struct can_bittiming_const esd_usb_3_data_bittiming_const = { 1110 .name = "esd_usb_3", 1111 .tseg1_min = 2, 1112 .tseg1_max = 32, 1113 .tseg2_min = 1, 1114 .tseg2_max = 16, 1115 .sjw_max = 8, 1116 .brp_min = 1, 1117 .brp_max = 32, 1118 .brp_inc = 1, 1119 }; 1120 1121 static int esd_usb_3_set_bittiming(struct net_device *netdev) 1122 { 1123 const struct can_bittiming_const *nom_btc = &esd_usb_3_nom_bittiming_const; 1124 const struct can_bittiming_const *data_btc = &esd_usb_3_data_bittiming_const; 1125 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1126 struct can_bittiming *nom_bt = &priv->can.bittiming; 1127 struct can_bittiming *data_bt = &priv->can.fd.data_bittiming; 1128 struct esd_usb_3_set_baudrate_msg_x *baud_x; 1129 union esd_usb_msg *msg; 1130 u16 flags = 0; 1131 int err; 1132 1133 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1134 if (!msg) 1135 return -ENOMEM; 1136 1137 baud_x = &msg->setbaud_x; 1138 1139 /* Canonical is the most reasonable mode for SocketCAN on CAN-USB/3 ... */ 1140 baud_x->mode = cpu_to_le16(ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL); 1141 1142 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1143 flags |= ESD_USB_3_BAUDRATE_FLAG_LOM; 1144 1145 baud_x->nom.brp = cpu_to_le16(nom_bt->brp & (nom_btc->brp_max - 1)); 1146 baud_x->nom.sjw = cpu_to_le16(nom_bt->sjw & (nom_btc->sjw_max - 1)); 1147 baud_x->nom.tseg1 = cpu_to_le16((nom_bt->prop_seg + nom_bt->phase_seg1) 1148 & (nom_btc->tseg1_max - 1)); 1149 baud_x->nom.tseg2 = cpu_to_le16(nom_bt->phase_seg2 & (nom_btc->tseg2_max - 1)); 1150 1151 if (priv->can.ctrlmode & CAN_CTRLMODE_FD) { 1152 baud_x->data.brp = cpu_to_le16(data_bt->brp & (data_btc->brp_max - 1)); 1153 baud_x->data.sjw = cpu_to_le16(data_bt->sjw & (data_btc->sjw_max - 1)); 1154 baud_x->data.tseg1 = cpu_to_le16((data_bt->prop_seg + data_bt->phase_seg1) 1155 & (data_btc->tseg1_max - 1)); 1156 baud_x->data.tseg2 = cpu_to_le16(data_bt->phase_seg2 & (data_btc->tseg2_max - 1)); 1157 flags |= ESD_USB_3_BAUDRATE_FLAG_FD; 1158 } 1159 1160 /* Currently this driver only supports the automatic TDC mode */ 1161 baud_x->tdc.tdc_mode = ESD_USB_3_TDC_MODE_AUTO; 1162 baud_x->tdc.ssp_offset = 0; 1163 baud_x->tdc.ssp_shift = 0; 1164 baud_x->tdc.tdc_filter = 0; 1165 1166 baud_x->flags = cpu_to_le16(flags); 1167 baud_x->net = priv->index; 1168 baud_x->rsvd = 0; 1169 1170 /* set len as # of 32bit words */ 1171 msg->hdr.len = sizeof(struct esd_usb_3_set_baudrate_msg_x) / sizeof(u32); 1172 msg->hdr.cmd = ESD_USB_CMD_SETBAUD; 1173 1174 netdev_dbg(netdev, 1175 "ctrlmode=%#x/%#x, esd-net=%u, esd-mode=%#x, esd-flags=%#x\n", 1176 priv->can.ctrlmode, priv->can.ctrlmode_supported, 1177 priv->index, le16_to_cpu(baud_x->mode), flags); 1178 1179 err = esd_usb_send_msg(priv->usb, msg); 1180 1181 kfree(msg); 1182 return err; 1183 } 1184 1185 static int esd_usb_get_berr_counter(const struct net_device *netdev, 1186 struct can_berr_counter *bec) 1187 { 1188 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1189 1190 bec->txerr = priv->bec.txerr; 1191 bec->rxerr = priv->bec.rxerr; 1192 1193 return 0; 1194 } 1195 1196 static int esd_usb_set_mode(struct net_device *netdev, enum can_mode mode) 1197 { 1198 switch (mode) { 1199 case CAN_MODE_START: 1200 netif_wake_queue(netdev); 1201 break; 1202 1203 default: 1204 return -EOPNOTSUPP; 1205 } 1206 1207 return 0; 1208 } 1209 1210 static int esd_usb_probe_one_net(struct usb_interface *intf, int index) 1211 { 1212 struct esd_usb *dev = usb_get_intfdata(intf); 1213 struct net_device *netdev; 1214 struct esd_usb_net_priv *priv; 1215 int err = 0; 1216 int i; 1217 1218 netdev = alloc_candev(sizeof(*priv), ESD_USB_MAX_TX_URBS); 1219 if (!netdev) { 1220 dev_err(&intf->dev, "couldn't alloc candev\n"); 1221 err = -ENOMEM; 1222 goto done; 1223 } 1224 1225 priv = netdev_priv(netdev); 1226 1227 init_usb_anchor(&priv->tx_submitted); 1228 atomic_set(&priv->active_tx_jobs, 0); 1229 1230 for (i = 0; i < ESD_USB_MAX_TX_URBS; i++) 1231 priv->tx_contexts[i].echo_index = ESD_USB_MAX_TX_URBS; 1232 1233 priv->usb = dev; 1234 priv->netdev = netdev; 1235 priv->index = index; 1236 1237 priv->can.state = CAN_STATE_STOPPED; 1238 priv->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY | 1239 CAN_CTRLMODE_CC_LEN8_DLC | 1240 CAN_CTRLMODE_BERR_REPORTING; 1241 1242 switch (le16_to_cpu(dev->udev->descriptor.idProduct)) { 1243 case ESD_USB_CANUSB3_PRODUCT_ID: 1244 priv->can.clock.freq = ESD_USB_3_CAN_CLOCK; 1245 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD; 1246 priv->can.bittiming_const = &esd_usb_3_nom_bittiming_const; 1247 priv->can.fd.data_bittiming_const = &esd_usb_3_data_bittiming_const; 1248 priv->can.do_set_bittiming = esd_usb_3_set_bittiming; 1249 priv->can.fd.do_set_data_bittiming = esd_usb_3_set_bittiming; 1250 break; 1251 1252 case ESD_USB_CANUSBM_PRODUCT_ID: 1253 priv->can.clock.freq = ESD_USB_M_CAN_CLOCK; 1254 priv->can.bittiming_const = &esd_usb_2_bittiming_const; 1255 priv->can.do_set_bittiming = esd_usb_2_set_bittiming; 1256 break; 1257 1258 case ESD_USB_CANUSB2_PRODUCT_ID: 1259 default: 1260 priv->can.clock.freq = ESD_USB_2_CAN_CLOCK; 1261 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 1262 priv->can.bittiming_const = &esd_usb_2_bittiming_const; 1263 priv->can.do_set_bittiming = esd_usb_2_set_bittiming; 1264 break; 1265 } 1266 1267 priv->can.do_set_mode = esd_usb_set_mode; 1268 priv->can.do_get_berr_counter = esd_usb_get_berr_counter; 1269 1270 netdev->flags |= IFF_ECHO; /* we support local echo */ 1271 1272 netdev->netdev_ops = &esd_usb_netdev_ops; 1273 netdev->ethtool_ops = &esd_usb_ethtool_ops; 1274 1275 SET_NETDEV_DEV(netdev, &intf->dev); 1276 netdev->dev_id = index; 1277 1278 err = register_candev(netdev); 1279 if (err) { 1280 dev_err(&intf->dev, "couldn't register CAN device: %pe\n", ERR_PTR(err)); 1281 free_candev(netdev); 1282 err = -ENOMEM; 1283 goto done; 1284 } 1285 1286 dev->nets[index] = priv; 1287 netdev_info(netdev, "registered\n"); 1288 1289 done: 1290 return err; 1291 } 1292 1293 /* probe function for new USB devices 1294 * 1295 * check version information and number of available 1296 * CAN interfaces 1297 */ 1298 static int esd_usb_probe(struct usb_interface *intf, 1299 const struct usb_device_id *id) 1300 { 1301 struct esd_usb *dev; 1302 union esd_usb_msg *msg; 1303 int i, err; 1304 1305 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1306 if (!dev) { 1307 err = -ENOMEM; 1308 goto done; 1309 } 1310 1311 dev->udev = interface_to_usbdev(intf); 1312 1313 init_usb_anchor(&dev->rx_submitted); 1314 1315 usb_set_intfdata(intf, dev); 1316 1317 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1318 if (!msg) { 1319 err = -ENOMEM; 1320 goto free_msg; 1321 } 1322 1323 /* query number of CAN interfaces (nets) */ 1324 msg->hdr.cmd = ESD_USB_CMD_VERSION; 1325 msg->hdr.len = sizeof(struct esd_usb_version_msg) / sizeof(u32); /* # of 32bit words */ 1326 msg->version.rsvd = 0; 1327 msg->version.flags = 0; 1328 msg->version.drv_version = 0; 1329 1330 err = esd_usb_send_msg(dev, msg); 1331 if (err < 0) { 1332 dev_err(&intf->dev, "sending version message failed\n"); 1333 goto free_msg; 1334 } 1335 1336 err = esd_usb_wait_msg(dev, msg); 1337 if (err < 0) { 1338 dev_err(&intf->dev, "no version message answer\n"); 1339 goto free_msg; 1340 } 1341 1342 dev->net_count = (int)msg->version_reply.nets; 1343 dev->version = le32_to_cpu(msg->version_reply.version); 1344 1345 if (device_create_file(&intf->dev, &dev_attr_firmware)) 1346 dev_err(&intf->dev, 1347 "Couldn't create device file for firmware\n"); 1348 1349 if (device_create_file(&intf->dev, &dev_attr_hardware)) 1350 dev_err(&intf->dev, 1351 "Couldn't create device file for hardware\n"); 1352 1353 if (device_create_file(&intf->dev, &dev_attr_nets)) 1354 dev_err(&intf->dev, 1355 "Couldn't create device file for nets\n"); 1356 1357 /* do per device probing */ 1358 for (i = 0; i < dev->net_count; i++) 1359 esd_usb_probe_one_net(intf, i); 1360 1361 free_msg: 1362 kfree(msg); 1363 if (err) 1364 kfree(dev); 1365 done: 1366 return err; 1367 } 1368 1369 /* called by the usb core when the device is removed from the system */ 1370 static void esd_usb_disconnect(struct usb_interface *intf) 1371 { 1372 struct esd_usb *dev = usb_get_intfdata(intf); 1373 struct net_device *netdev; 1374 int i; 1375 1376 device_remove_file(&intf->dev, &dev_attr_firmware); 1377 device_remove_file(&intf->dev, &dev_attr_hardware); 1378 device_remove_file(&intf->dev, &dev_attr_nets); 1379 1380 usb_set_intfdata(intf, NULL); 1381 1382 if (dev) { 1383 dev->in_usb_disconnect = 1; 1384 for (i = 0; i < dev->net_count; i++) { 1385 if (dev->nets[i]) { 1386 netdev = dev->nets[i]->netdev; 1387 netdev_info(netdev, "unregister\n"); 1388 unregister_netdev(netdev); 1389 free_candev(netdev); 1390 } 1391 } 1392 unlink_all_urbs(dev); 1393 kfree(dev); 1394 } 1395 } 1396 1397 /* usb specific object needed to register this driver with the usb subsystem */ 1398 static struct usb_driver esd_usb_driver = { 1399 .name = KBUILD_MODNAME, 1400 .probe = esd_usb_probe, 1401 .disconnect = esd_usb_disconnect, 1402 .id_table = esd_usb_table, 1403 }; 1404 1405 module_usb_driver(esd_usb_driver); 1406