drivers/net/can/usb/mcba_usb.c

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