drivers/net/can/usb/mcba_usb.c

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