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