1 // SPDX-License-Identifier: GPL-2.0-only 2 /* SocketCAN driver for Microchip CAN BUS Analyzer Tool 3 * 4 * Copyright (C) 2017 Mobica Limited 5 * 6 * This driver is inspired by the 4.6.2 version of net/can/usb/usb_8dev.c 7 */ 8 9 #include <asm/unaligned.h> 10 #include <linux/can.h> 11 #include <linux/can/dev.h> 12 #include <linux/can/error.h> 13 #include <linux/can/led.h> 14 #include <linux/module.h> 15 #include <linux/netdevice.h> 16 #include <linux/signal.h> 17 #include <linux/slab.h> 18 #include <linux/usb.h> 19 20 /* vendor and product id */ 21 #define MCBA_MODULE_NAME "mcba_usb" 22 #define MCBA_VENDOR_ID 0x04d8 23 #define MCBA_PRODUCT_ID 0x0a30 24 25 /* driver constants */ 26 #define MCBA_MAX_RX_URBS 20 27 #define MCBA_MAX_TX_URBS 20 28 #define MCBA_CTX_FREE MCBA_MAX_TX_URBS 29 30 /* RX buffer must be bigger than msg size since at the 31 * beggining USB messages are stacked. 32 */ 33 #define MCBA_USB_RX_BUFF_SIZE 64 34 #define MCBA_USB_TX_BUFF_SIZE (sizeof(struct mcba_usb_msg)) 35 36 /* MCBA endpoint numbers */ 37 #define MCBA_USB_EP_IN 1 38 #define MCBA_USB_EP_OUT 1 39 40 /* Microchip command id */ 41 #define MBCA_CMD_RECEIVE_MESSAGE 0xE3 42 #define MBCA_CMD_I_AM_ALIVE_FROM_CAN 0xF5 43 #define MBCA_CMD_I_AM_ALIVE_FROM_USB 0xF7 44 #define MBCA_CMD_CHANGE_BIT_RATE 0xA1 45 #define MBCA_CMD_TRANSMIT_MESSAGE_EV 0xA3 46 #define MBCA_CMD_SETUP_TERMINATION_RESISTANCE 0xA8 47 #define MBCA_CMD_READ_FW_VERSION 0xA9 48 #define MBCA_CMD_NOTHING_TO_SEND 0xFF 49 #define MBCA_CMD_TRANSMIT_MESSAGE_RSP 0xE2 50 51 #define MCBA_VER_REQ_USB 1 52 #define MCBA_VER_REQ_CAN 2 53 54 #define MCBA_SIDL_EXID_MASK 0x8 55 #define MCBA_DLC_MASK 0xf 56 #define MCBA_DLC_RTR_MASK 0x40 57 58 #define MCBA_CAN_STATE_WRN_TH 95 59 #define MCBA_CAN_STATE_ERR_PSV_TH 127 60 61 #define MCBA_TERMINATION_DISABLED CAN_TERMINATION_DISABLED 62 #define MCBA_TERMINATION_ENABLED 120 63 64 struct mcba_usb_ctx { 65 struct mcba_priv *priv; 66 u32 ndx; 67 u8 dlc; 68 bool can; 69 }; 70 71 /* Structure to hold all of our device specific stuff */ 72 struct mcba_priv { 73 struct can_priv can; /* must be the first member */ 74 struct sk_buff *echo_skb[MCBA_MAX_TX_URBS]; 75 struct mcba_usb_ctx tx_context[MCBA_MAX_TX_URBS]; 76 struct usb_device *udev; 77 struct net_device *netdev; 78 struct usb_anchor tx_submitted; 79 struct usb_anchor rx_submitted; 80 struct can_berr_counter bec; 81 bool usb_ka_first_pass; 82 bool can_ka_first_pass; 83 bool can_speed_check; 84 atomic_t free_ctx_cnt; 85 }; 86 87 /* CAN frame */ 88 struct __packed mcba_usb_msg_can { 89 u8 cmd_id; 90 __be16 eid; 91 __be16 sid; 92 u8 dlc; 93 u8 data[8]; 94 u8 timestamp[4]; 95 u8 checksum; 96 }; 97 98 /* command frame */ 99 struct __packed mcba_usb_msg { 100 u8 cmd_id; 101 u8 unused[18]; 102 }; 103 104 struct __packed mcba_usb_msg_ka_usb { 105 u8 cmd_id; 106 u8 termination_state; 107 u8 soft_ver_major; 108 u8 soft_ver_minor; 109 u8 unused[15]; 110 }; 111 112 struct __packed mcba_usb_msg_ka_can { 113 u8 cmd_id; 114 u8 tx_err_cnt; 115 u8 rx_err_cnt; 116 u8 rx_buff_ovfl; 117 u8 tx_bus_off; 118 __be16 can_bitrate; 119 __le16 rx_lost; 120 u8 can_stat; 121 u8 soft_ver_major; 122 u8 soft_ver_minor; 123 u8 debug_mode; 124 u8 test_complete; 125 u8 test_result; 126 u8 unused[4]; 127 }; 128 129 struct __packed mcba_usb_msg_change_bitrate { 130 u8 cmd_id; 131 __be16 bitrate; 132 u8 unused[16]; 133 }; 134 135 struct __packed mcba_usb_msg_termination { 136 u8 cmd_id; 137 u8 termination; 138 u8 unused[17]; 139 }; 140 141 struct __packed mcba_usb_msg_fw_ver { 142 u8 cmd_id; 143 u8 pic; 144 u8 unused[17]; 145 }; 146 147 static const struct usb_device_id mcba_usb_table[] = { 148 { USB_DEVICE(MCBA_VENDOR_ID, MCBA_PRODUCT_ID) }, 149 {} /* Terminating entry */ 150 }; 151 152 MODULE_DEVICE_TABLE(usb, mcba_usb_table); 153 154 static const u16 mcba_termination[] = { MCBA_TERMINATION_DISABLED, 155 MCBA_TERMINATION_ENABLED }; 156 157 static const u32 mcba_bitrate[] = { 20000, 33333, 50000, 80000, 83333, 158 100000, 125000, 150000, 175000, 200000, 159 225000, 250000, 275000, 300000, 500000, 160 625000, 800000, 1000000 }; 161 162 static inline void mcba_init_ctx(struct mcba_priv *priv) 163 { 164 int i = 0; 165 166 for (i = 0; i < MCBA_MAX_TX_URBS; i++) { 167 priv->tx_context[i].ndx = MCBA_CTX_FREE; 168 priv->tx_context[i].priv = priv; 169 } 170 171 atomic_set(&priv->free_ctx_cnt, ARRAY_SIZE(priv->tx_context)); 172 } 173 174 static inline struct mcba_usb_ctx *mcba_usb_get_free_ctx(struct mcba_priv *priv, 175 struct can_frame *cf) 176 { 177 int i = 0; 178 struct mcba_usb_ctx *ctx = NULL; 179 180 for (i = 0; i < MCBA_MAX_TX_URBS; i++) { 181 if (priv->tx_context[i].ndx == MCBA_CTX_FREE) { 182 ctx = &priv->tx_context[i]; 183 ctx->ndx = i; 184 185 if (cf) { 186 ctx->can = true; 187 ctx->dlc = cf->can_dlc; 188 } else { 189 ctx->can = false; 190 ctx->dlc = 0; 191 } 192 193 atomic_dec(&priv->free_ctx_cnt); 194 break; 195 } 196 } 197 198 if (!atomic_read(&priv->free_ctx_cnt)) 199 /* That was the last free ctx. Slow down tx path */ 200 netif_stop_queue(priv->netdev); 201 202 return ctx; 203 } 204 205 /* mcba_usb_free_ctx and mcba_usb_get_free_ctx are executed by different 206 * threads. The order of execution in below function is important. 207 */ 208 static inline void mcba_usb_free_ctx(struct mcba_usb_ctx *ctx) 209 { 210 /* Increase number of free ctxs before freeing ctx */ 211 atomic_inc(&ctx->priv->free_ctx_cnt); 212 213 ctx->ndx = MCBA_CTX_FREE; 214 215 /* Wake up the queue once ctx is marked free */ 216 netif_wake_queue(ctx->priv->netdev); 217 } 218 219 static void mcba_usb_write_bulk_callback(struct urb *urb) 220 { 221 struct mcba_usb_ctx *ctx = urb->context; 222 struct net_device *netdev; 223 224 WARN_ON(!ctx); 225 226 netdev = ctx->priv->netdev; 227 228 /* free up our allocated buffer */ 229 usb_free_coherent(urb->dev, urb->transfer_buffer_length, 230 urb->transfer_buffer, urb->transfer_dma); 231 232 if (ctx->can) { 233 if (!netif_device_present(netdev)) 234 return; 235 236 netdev->stats.tx_packets++; 237 netdev->stats.tx_bytes += ctx->dlc; 238 239 can_led_event(netdev, CAN_LED_EVENT_TX); 240 can_get_echo_skb(netdev, ctx->ndx); 241 } 242 243 if (urb->status) 244 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 245 246 /* Release the context */ 247 mcba_usb_free_ctx(ctx); 248 } 249 250 /* Send data to device */ 251 static netdev_tx_t mcba_usb_xmit(struct mcba_priv *priv, 252 struct mcba_usb_msg *usb_msg, 253 struct mcba_usb_ctx *ctx) 254 { 255 struct urb *urb; 256 u8 *buf; 257 int err; 258 259 /* create a URB, and a buffer for it, and copy the data to the URB */ 260 urb = usb_alloc_urb(0, GFP_ATOMIC); 261 if (!urb) 262 return -ENOMEM; 263 264 buf = usb_alloc_coherent(priv->udev, MCBA_USB_TX_BUFF_SIZE, GFP_ATOMIC, 265 &urb->transfer_dma); 266 if (!buf) { 267 err = -ENOMEM; 268 goto nomembuf; 269 } 270 271 memcpy(buf, usb_msg, MCBA_USB_TX_BUFF_SIZE); 272 273 usb_fill_bulk_urb(urb, priv->udev, 274 usb_sndbulkpipe(priv->udev, MCBA_USB_EP_OUT), buf, 275 MCBA_USB_TX_BUFF_SIZE, mcba_usb_write_bulk_callback, 276 ctx); 277 278 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 279 usb_anchor_urb(urb, &priv->tx_submitted); 280 281 err = usb_submit_urb(urb, GFP_ATOMIC); 282 if (unlikely(err)) 283 goto failed; 284 285 /* Release our reference to this URB, the USB core will eventually free 286 * it entirely. 287 */ 288 usb_free_urb(urb); 289 290 return 0; 291 292 failed: 293 usb_unanchor_urb(urb); 294 usb_free_coherent(priv->udev, MCBA_USB_TX_BUFF_SIZE, buf, 295 urb->transfer_dma); 296 297 if (err == -ENODEV) 298 netif_device_detach(priv->netdev); 299 else 300 netdev_warn(priv->netdev, "failed tx_urb %d\n", err); 301 302 nomembuf: 303 usb_free_urb(urb); 304 305 return err; 306 } 307 308 /* Send data to device */ 309 static netdev_tx_t mcba_usb_start_xmit(struct sk_buff *skb, 310 struct net_device *netdev) 311 { 312 struct mcba_priv *priv = netdev_priv(netdev); 313 struct can_frame *cf = (struct can_frame *)skb->data; 314 struct mcba_usb_ctx *ctx = NULL; 315 struct net_device_stats *stats = &priv->netdev->stats; 316 u16 sid; 317 int err; 318 struct mcba_usb_msg_can usb_msg = { 319 .cmd_id = MBCA_CMD_TRANSMIT_MESSAGE_EV 320 }; 321 322 if (can_dropped_invalid_skb(netdev, skb)) 323 return NETDEV_TX_OK; 324 325 ctx = mcba_usb_get_free_ctx(priv, cf); 326 if (!ctx) 327 return NETDEV_TX_BUSY; 328 329 can_put_echo_skb(skb, priv->netdev, ctx->ndx); 330 331 if (cf->can_id & CAN_EFF_FLAG) { 332 /* SIDH | SIDL | EIDH | EIDL 333 * 28 - 21 | 20 19 18 x x x 17 16 | 15 - 8 | 7 - 0 334 */ 335 sid = MCBA_SIDL_EXID_MASK; 336 /* store 28-18 bits */ 337 sid |= (cf->can_id & 0x1ffc0000) >> 13; 338 /* store 17-16 bits */ 339 sid |= (cf->can_id & 0x30000) >> 16; 340 put_unaligned_be16(sid, &usb_msg.sid); 341 342 /* store 15-0 bits */ 343 put_unaligned_be16(cf->can_id & 0xffff, &usb_msg.eid); 344 } else { 345 /* SIDH | SIDL 346 * 10 - 3 | 2 1 0 x x x x x 347 */ 348 put_unaligned_be16((cf->can_id & CAN_SFF_MASK) << 5, 349 &usb_msg.sid); 350 usb_msg.eid = 0; 351 } 352 353 usb_msg.dlc = cf->can_dlc; 354 355 memcpy(usb_msg.data, cf->data, usb_msg.dlc); 356 357 if (cf->can_id & CAN_RTR_FLAG) 358 usb_msg.dlc |= MCBA_DLC_RTR_MASK; 359 360 err = mcba_usb_xmit(priv, (struct mcba_usb_msg *)&usb_msg, ctx); 361 if (err) 362 goto xmit_failed; 363 364 return NETDEV_TX_OK; 365 366 xmit_failed: 367 can_free_echo_skb(priv->netdev, ctx->ndx); 368 mcba_usb_free_ctx(ctx); 369 dev_kfree_skb(skb); 370 stats->tx_dropped++; 371 372 return NETDEV_TX_OK; 373 } 374 375 /* Send cmd to device */ 376 static void mcba_usb_xmit_cmd(struct mcba_priv *priv, 377 struct mcba_usb_msg *usb_msg) 378 { 379 struct mcba_usb_ctx *ctx = NULL; 380 int err; 381 382 ctx = mcba_usb_get_free_ctx(priv, NULL); 383 if (!ctx) { 384 netdev_err(priv->netdev, 385 "Lack of free ctx. Sending (%d) cmd aborted", 386 usb_msg->cmd_id); 387 388 return; 389 } 390 391 err = mcba_usb_xmit(priv, usb_msg, ctx); 392 if (err) 393 netdev_err(priv->netdev, "Failed to send cmd (%d)", 394 usb_msg->cmd_id); 395 } 396 397 static void mcba_usb_xmit_change_bitrate(struct mcba_priv *priv, u16 bitrate) 398 { 399 struct mcba_usb_msg_change_bitrate usb_msg = { 400 .cmd_id = MBCA_CMD_CHANGE_BIT_RATE 401 }; 402 403 put_unaligned_be16(bitrate, &usb_msg.bitrate); 404 405 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg); 406 } 407 408 static void mcba_usb_xmit_read_fw_ver(struct mcba_priv *priv, u8 pic) 409 { 410 struct mcba_usb_msg_fw_ver usb_msg = { 411 .cmd_id = MBCA_CMD_READ_FW_VERSION, 412 .pic = pic 413 }; 414 415 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg); 416 } 417 418 static void mcba_usb_process_can(struct mcba_priv *priv, 419 struct mcba_usb_msg_can *msg) 420 { 421 struct can_frame *cf; 422 struct sk_buff *skb; 423 struct net_device_stats *stats = &priv->netdev->stats; 424 u16 sid; 425 426 skb = alloc_can_skb(priv->netdev, &cf); 427 if (!skb) 428 return; 429 430 sid = get_unaligned_be16(&msg->sid); 431 432 if (sid & MCBA_SIDL_EXID_MASK) { 433 /* SIDH | SIDL | EIDH | EIDL 434 * 28 - 21 | 20 19 18 x x x 17 16 | 15 - 8 | 7 - 0 435 */ 436 cf->can_id = CAN_EFF_FLAG; 437 438 /* store 28-18 bits */ 439 cf->can_id |= (sid & 0xffe0) << 13; 440 /* store 17-16 bits */ 441 cf->can_id |= (sid & 3) << 16; 442 /* store 15-0 bits */ 443 cf->can_id |= get_unaligned_be16(&msg->eid); 444 } else { 445 /* SIDH | SIDL 446 * 10 - 3 | 2 1 0 x x x x x 447 */ 448 cf->can_id = (sid & 0xffe0) >> 5; 449 } 450 451 if (msg->dlc & MCBA_DLC_RTR_MASK) 452 cf->can_id |= CAN_RTR_FLAG; 453 454 cf->can_dlc = get_can_dlc(msg->dlc & MCBA_DLC_MASK); 455 456 memcpy(cf->data, msg->data, cf->can_dlc); 457 458 stats->rx_packets++; 459 stats->rx_bytes += cf->can_dlc; 460 461 can_led_event(priv->netdev, CAN_LED_EVENT_RX); 462 netif_rx(skb); 463 } 464 465 static void mcba_usb_process_ka_usb(struct mcba_priv *priv, 466 struct mcba_usb_msg_ka_usb *msg) 467 { 468 if (unlikely(priv->usb_ka_first_pass)) { 469 netdev_info(priv->netdev, "PIC USB version %hhu.%hhu\n", 470 msg->soft_ver_major, msg->soft_ver_minor); 471 472 priv->usb_ka_first_pass = false; 473 } 474 475 if (msg->termination_state) 476 priv->can.termination = MCBA_TERMINATION_ENABLED; 477 else 478 priv->can.termination = MCBA_TERMINATION_DISABLED; 479 } 480 481 static u32 convert_can2host_bitrate(struct mcba_usb_msg_ka_can *msg) 482 { 483 const u32 bitrate = get_unaligned_be16(&msg->can_bitrate); 484 485 if ((bitrate == 33) || (bitrate == 83)) 486 return bitrate * 1000 + 333; 487 else 488 return bitrate * 1000; 489 } 490 491 static void mcba_usb_process_ka_can(struct mcba_priv *priv, 492 struct mcba_usb_msg_ka_can *msg) 493 { 494 if (unlikely(priv->can_ka_first_pass)) { 495 netdev_info(priv->netdev, "PIC CAN version %hhu.%hhu\n", 496 msg->soft_ver_major, msg->soft_ver_minor); 497 498 priv->can_ka_first_pass = false; 499 } 500 501 if (unlikely(priv->can_speed_check)) { 502 const u32 bitrate = convert_can2host_bitrate(msg); 503 504 priv->can_speed_check = false; 505 506 if (bitrate != priv->can.bittiming.bitrate) 507 netdev_err( 508 priv->netdev, 509 "Wrong bitrate reported by the device (%u). Expected %u", 510 bitrate, priv->can.bittiming.bitrate); 511 } 512 513 priv->bec.txerr = msg->tx_err_cnt; 514 priv->bec.rxerr = msg->rx_err_cnt; 515 516 if (msg->tx_bus_off) 517 priv->can.state = CAN_STATE_BUS_OFF; 518 519 else if ((priv->bec.txerr > MCBA_CAN_STATE_ERR_PSV_TH) || 520 (priv->bec.rxerr > MCBA_CAN_STATE_ERR_PSV_TH)) 521 priv->can.state = CAN_STATE_ERROR_PASSIVE; 522 523 else if ((priv->bec.txerr > MCBA_CAN_STATE_WRN_TH) || 524 (priv->bec.rxerr > MCBA_CAN_STATE_WRN_TH)) 525 priv->can.state = CAN_STATE_ERROR_WARNING; 526 } 527 528 static void mcba_usb_process_rx(struct mcba_priv *priv, 529 struct mcba_usb_msg *msg) 530 { 531 switch (msg->cmd_id) { 532 case MBCA_CMD_I_AM_ALIVE_FROM_CAN: 533 mcba_usb_process_ka_can(priv, 534 (struct mcba_usb_msg_ka_can *)msg); 535 break; 536 537 case MBCA_CMD_I_AM_ALIVE_FROM_USB: 538 mcba_usb_process_ka_usb(priv, 539 (struct mcba_usb_msg_ka_usb *)msg); 540 break; 541 542 case MBCA_CMD_RECEIVE_MESSAGE: 543 mcba_usb_process_can(priv, (struct mcba_usb_msg_can *)msg); 544 break; 545 546 case MBCA_CMD_NOTHING_TO_SEND: 547 /* Side effect of communication between PIC_USB and PIC_CAN. 548 * PIC_CAN is telling us that it has nothing to send 549 */ 550 break; 551 552 case MBCA_CMD_TRANSMIT_MESSAGE_RSP: 553 /* Transmission response from the device containing timestamp */ 554 break; 555 556 default: 557 netdev_warn(priv->netdev, "Unsupported msg (0x%hhX)", 558 msg->cmd_id); 559 break; 560 } 561 } 562 563 /* Callback for reading data from device 564 * 565 * Check urb status, call read function and resubmit urb read operation. 566 */ 567 static void mcba_usb_read_bulk_callback(struct urb *urb) 568 { 569 struct mcba_priv *priv = urb->context; 570 struct net_device *netdev; 571 int retval; 572 int pos = 0; 573 574 netdev = priv->netdev; 575 576 if (!netif_device_present(netdev)) 577 return; 578 579 switch (urb->status) { 580 case 0: /* success */ 581 break; 582 583 case -ENOENT: 584 case -EPIPE: 585 case -EPROTO: 586 case -ESHUTDOWN: 587 return; 588 589 default: 590 netdev_info(netdev, "Rx URB aborted (%d)\n", urb->status); 591 592 goto resubmit_urb; 593 } 594 595 while (pos < urb->actual_length) { 596 struct mcba_usb_msg *msg; 597 598 if (pos + sizeof(struct mcba_usb_msg) > urb->actual_length) { 599 netdev_err(priv->netdev, "format error\n"); 600 break; 601 } 602 603 msg = (struct mcba_usb_msg *)(urb->transfer_buffer + pos); 604 mcba_usb_process_rx(priv, msg); 605 606 pos += sizeof(struct mcba_usb_msg); 607 } 608 609 resubmit_urb: 610 611 usb_fill_bulk_urb(urb, priv->udev, 612 usb_rcvbulkpipe(priv->udev, MCBA_USB_EP_OUT), 613 urb->transfer_buffer, MCBA_USB_RX_BUFF_SIZE, 614 mcba_usb_read_bulk_callback, priv); 615 616 retval = usb_submit_urb(urb, GFP_ATOMIC); 617 618 if (retval == -ENODEV) 619 netif_device_detach(netdev); 620 else if (retval) 621 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n", 622 retval); 623 } 624 625 /* Start USB device */ 626 static int mcba_usb_start(struct mcba_priv *priv) 627 { 628 struct net_device *netdev = priv->netdev; 629 int err, i; 630 631 mcba_init_ctx(priv); 632 633 for (i = 0; i < MCBA_MAX_RX_URBS; i++) { 634 struct urb *urb = NULL; 635 u8 *buf; 636 637 /* create a URB, and a buffer for it */ 638 urb = usb_alloc_urb(0, GFP_KERNEL); 639 if (!urb) { 640 err = -ENOMEM; 641 break; 642 } 643 644 buf = usb_alloc_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE, 645 GFP_KERNEL, &urb->transfer_dma); 646 if (!buf) { 647 netdev_err(netdev, "No memory left for USB buffer\n"); 648 usb_free_urb(urb); 649 err = -ENOMEM; 650 break; 651 } 652 653 usb_fill_bulk_urb(urb, priv->udev, 654 usb_rcvbulkpipe(priv->udev, MCBA_USB_EP_IN), 655 buf, MCBA_USB_RX_BUFF_SIZE, 656 mcba_usb_read_bulk_callback, priv); 657 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 658 usb_anchor_urb(urb, &priv->rx_submitted); 659 660 err = usb_submit_urb(urb, GFP_KERNEL); 661 if (err) { 662 usb_unanchor_urb(urb); 663 usb_free_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE, 664 buf, urb->transfer_dma); 665 usb_free_urb(urb); 666 break; 667 } 668 669 /* Drop reference, USB core will take care of freeing it */ 670 usb_free_urb(urb); 671 } 672 673 /* Did we submit any URBs */ 674 if (i == 0) { 675 netdev_warn(netdev, "couldn't setup read URBs\n"); 676 return err; 677 } 678 679 /* Warn if we've couldn't transmit all the URBs */ 680 if (i < MCBA_MAX_RX_URBS) 681 netdev_warn(netdev, "rx performance may be slow\n"); 682 683 mcba_usb_xmit_read_fw_ver(priv, MCBA_VER_REQ_USB); 684 mcba_usb_xmit_read_fw_ver(priv, MCBA_VER_REQ_CAN); 685 686 return err; 687 } 688 689 /* Open USB device */ 690 static int mcba_usb_open(struct net_device *netdev) 691 { 692 struct mcba_priv *priv = netdev_priv(netdev); 693 int err; 694 695 /* common open */ 696 err = open_candev(netdev); 697 if (err) 698 return err; 699 700 priv->can_speed_check = true; 701 priv->can.state = CAN_STATE_ERROR_ACTIVE; 702 703 can_led_event(netdev, CAN_LED_EVENT_OPEN); 704 netif_start_queue(netdev); 705 706 return 0; 707 } 708 709 static void mcba_urb_unlink(struct mcba_priv *priv) 710 { 711 usb_kill_anchored_urbs(&priv->rx_submitted); 712 usb_kill_anchored_urbs(&priv->tx_submitted); 713 } 714 715 /* Close USB device */ 716 static int mcba_usb_close(struct net_device *netdev) 717 { 718 struct mcba_priv *priv = netdev_priv(netdev); 719 720 priv->can.state = CAN_STATE_STOPPED; 721 722 netif_stop_queue(netdev); 723 724 /* Stop polling */ 725 mcba_urb_unlink(priv); 726 727 close_candev(netdev); 728 can_led_event(netdev, CAN_LED_EVENT_STOP); 729 730 return 0; 731 } 732 733 /* Set network device mode 734 * 735 * Maybe we should leave this function empty, because the device 736 * set mode variable with open command. 737 */ 738 static int mcba_net_set_mode(struct net_device *netdev, enum can_mode mode) 739 { 740 return 0; 741 } 742 743 static int mcba_net_get_berr_counter(const struct net_device *netdev, 744 struct can_berr_counter *bec) 745 { 746 struct mcba_priv *priv = netdev_priv(netdev); 747 748 bec->txerr = priv->bec.txerr; 749 bec->rxerr = priv->bec.rxerr; 750 751 return 0; 752 } 753 754 static const struct net_device_ops mcba_netdev_ops = { 755 .ndo_open = mcba_usb_open, 756 .ndo_stop = mcba_usb_close, 757 .ndo_start_xmit = mcba_usb_start_xmit, 758 }; 759 760 /* Microchip CANBUS has hardcoded bittiming values by default. 761 * This function sends request via USB to change the speed and align bittiming 762 * values for presentation purposes only 763 */ 764 static int mcba_net_set_bittiming(struct net_device *netdev) 765 { 766 struct mcba_priv *priv = netdev_priv(netdev); 767 const u16 bitrate_kbps = priv->can.bittiming.bitrate / 1000; 768 769 mcba_usb_xmit_change_bitrate(priv, bitrate_kbps); 770 771 return 0; 772 } 773 774 static int mcba_set_termination(struct net_device *netdev, u16 term) 775 { 776 struct mcba_priv *priv = netdev_priv(netdev); 777 struct mcba_usb_msg_termination usb_msg = { 778 .cmd_id = MBCA_CMD_SETUP_TERMINATION_RESISTANCE 779 }; 780 781 if (term == MCBA_TERMINATION_ENABLED) 782 usb_msg.termination = 1; 783 else 784 usb_msg.termination = 0; 785 786 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg); 787 788 return 0; 789 } 790 791 static int mcba_usb_probe(struct usb_interface *intf, 792 const struct usb_device_id *id) 793 { 794 struct net_device *netdev; 795 struct mcba_priv *priv; 796 int err = -ENOMEM; 797 struct usb_device *usbdev = interface_to_usbdev(intf); 798 799 netdev = alloc_candev(sizeof(struct mcba_priv), MCBA_MAX_TX_URBS); 800 if (!netdev) { 801 dev_err(&intf->dev, "Couldn't alloc candev\n"); 802 return -ENOMEM; 803 } 804 805 priv = netdev_priv(netdev); 806 807 priv->udev = usbdev; 808 priv->netdev = netdev; 809 priv->usb_ka_first_pass = true; 810 priv->can_ka_first_pass = true; 811 priv->can_speed_check = false; 812 813 init_usb_anchor(&priv->rx_submitted); 814 init_usb_anchor(&priv->tx_submitted); 815 816 usb_set_intfdata(intf, priv); 817 818 /* Init CAN device */ 819 priv->can.state = CAN_STATE_STOPPED; 820 priv->can.termination_const = mcba_termination; 821 priv->can.termination_const_cnt = ARRAY_SIZE(mcba_termination); 822 priv->can.bitrate_const = mcba_bitrate; 823 priv->can.bitrate_const_cnt = ARRAY_SIZE(mcba_bitrate); 824 825 priv->can.do_set_termination = mcba_set_termination; 826 priv->can.do_set_mode = mcba_net_set_mode; 827 priv->can.do_get_berr_counter = mcba_net_get_berr_counter; 828 priv->can.do_set_bittiming = mcba_net_set_bittiming; 829 830 netdev->netdev_ops = &mcba_netdev_ops; 831 832 netdev->flags |= IFF_ECHO; /* we support local echo */ 833 834 SET_NETDEV_DEV(netdev, &intf->dev); 835 836 err = register_candev(netdev); 837 if (err) { 838 netdev_err(netdev, "couldn't register CAN device: %d\n", err); 839 840 goto cleanup_free_candev; 841 } 842 843 devm_can_led_init(netdev); 844 845 /* Start USB dev only if we have successfully registered CAN device */ 846 err = mcba_usb_start(priv); 847 if (err) { 848 if (err == -ENODEV) 849 netif_device_detach(priv->netdev); 850 851 netdev_warn(netdev, "couldn't start device: %d\n", err); 852 853 goto cleanup_unregister_candev; 854 } 855 856 dev_info(&intf->dev, "Microchip CAN BUS Analyzer connected\n"); 857 858 return 0; 859 860 cleanup_unregister_candev: 861 unregister_candev(priv->netdev); 862 863 cleanup_free_candev: 864 free_candev(netdev); 865 866 return err; 867 } 868 869 /* Called by the usb core when driver is unloaded or device is removed */ 870 static void mcba_usb_disconnect(struct usb_interface *intf) 871 { 872 struct mcba_priv *priv = usb_get_intfdata(intf); 873 874 usb_set_intfdata(intf, NULL); 875 876 netdev_info(priv->netdev, "device disconnected\n"); 877 878 unregister_candev(priv->netdev); 879 mcba_urb_unlink(priv); 880 free_candev(priv->netdev); 881 } 882 883 static struct usb_driver mcba_usb_driver = { 884 .name = MCBA_MODULE_NAME, 885 .probe = mcba_usb_probe, 886 .disconnect = mcba_usb_disconnect, 887 .id_table = mcba_usb_table, 888 }; 889 890 module_usb_driver(mcba_usb_driver); 891 892 MODULE_AUTHOR("Remigiusz Kołłątaj <remigiusz.kollataj@mobica.com>"); 893 MODULE_DESCRIPTION("SocketCAN driver for Microchip CAN BUS Analyzer Tool"); 894 MODULE_LICENSE("GPL v2"); 895