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