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