drivers/net/can/usb/usb_8dev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * CAN driver for "8 devices" USB2CAN converter
   4  *
   5  * Copyright (C) 2012 Bernd Krumboeck ([email protected])
   6  *
   7  * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c
   8  * and drivers/net/can/usb/esd_usb2.c
   9  *
  10  * Many thanks to Gerhard Bertelsmann ([email protected])
  11  * for testing and fixing this driver. Also many thanks to "8 devices",
  12  * who were very cooperative and answered my questions.
  13  */
  14
  15 #include <linux/ethtool.h>
  16 #include <linux/signal.h>
  17 #include <linux/slab.h>
  18 #include <linux/module.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/usb.h>
  21
  22 #include <linux/can.h>
  23 #include <linux/can/dev.h>
  24 #include <linux/can/error.h>
  25
  26 /* driver constants */
  27 #define MAX_RX_URBS                     20
  28 #define MAX_TX_URBS                     20
  29 #define RX_BUFFER_SIZE                  64
  30
  31 /* vendor and product id */
  32 #define USB_8DEV_VENDOR_ID              0x0483
  33 #define USB_8DEV_PRODUCT_ID             0x1234
  34
  35 /* endpoints */
  36 enum usb_8dev_endpoint {
  37         USB_8DEV_ENDP_DATA_RX = 1,
  38         USB_8DEV_ENDP_DATA_TX,
  39         USB_8DEV_ENDP_CMD_RX,
  40         USB_8DEV_ENDP_CMD_TX
  41 };
  42
  43 /* device CAN clock */
  44 #define USB_8DEV_ABP_CLOCK              32000000
  45
  46 /* setup flags */
  47 #define USB_8DEV_SILENT                 0x01
  48 #define USB_8DEV_LOOPBACK               0x02
  49 #define USB_8DEV_DISABLE_AUTO_RESTRANS  0x04
  50 #define USB_8DEV_STATUS_FRAME           0x08
  51
  52 /* commands */
  53 enum usb_8dev_cmd {
  54         USB_8DEV_RESET = 1,
  55         USB_8DEV_OPEN,
  56         USB_8DEV_CLOSE,
  57         USB_8DEV_SET_SPEED,
  58         USB_8DEV_SET_MASK_FILTER,
  59         USB_8DEV_GET_STATUS,
  60         USB_8DEV_GET_STATISTICS,
  61         USB_8DEV_GET_SERIAL,
  62         USB_8DEV_GET_SOFTW_VER,
  63         USB_8DEV_GET_HARDW_VER,
  64         USB_8DEV_RESET_TIMESTAMP,
  65         USB_8DEV_GET_SOFTW_HARDW_VER
  66 };
  67
  68 /* command options */
  69 #define USB_8DEV_BAUD_MANUAL            0x09
  70 #define USB_8DEV_CMD_START              0x11
  71 #define USB_8DEV_CMD_END                0x22
  72
  73 #define USB_8DEV_CMD_SUCCESS            0
  74 #define USB_8DEV_CMD_ERROR              255
  75
  76 #define USB_8DEV_CMD_TIMEOUT            1000
  77
  78 /* frames */
  79 #define USB_8DEV_DATA_START             0x55
  80 #define USB_8DEV_DATA_END               0xAA
  81
  82 #define USB_8DEV_TYPE_CAN_FRAME         0
  83 #define USB_8DEV_TYPE_ERROR_FRAME       3
  84
  85 #define USB_8DEV_EXTID                  0x01
  86 #define USB_8DEV_RTR                    0x02
  87 #define USB_8DEV_ERR_FLAG               0x04
  88
  89 /* status */
  90 #define USB_8DEV_STATUSMSG_OK           0x00  /* Normal condition. */
  91 #define USB_8DEV_STATUSMSG_OVERRUN      0x01  /* Overrun occurred when sending */
  92 #define USB_8DEV_STATUSMSG_BUSLIGHT     0x02  /* Error counter has reached 96 */
  93 #define USB_8DEV_STATUSMSG_BUSHEAVY     0x03  /* Error count. has reached 128 */
  94 #define USB_8DEV_STATUSMSG_BUSOFF       0x04  /* Device is in BUSOFF */
  95 #define USB_8DEV_STATUSMSG_STUFF        0x20  /* Stuff Error */
  96 #define USB_8DEV_STATUSMSG_FORM         0x21  /* Form Error */
  97 #define USB_8DEV_STATUSMSG_ACK          0x23  /* Ack Error */
  98 #define USB_8DEV_STATUSMSG_BIT0         0x24  /* Bit1 Error */
  99 #define USB_8DEV_STATUSMSG_BIT1         0x25  /* Bit0 Error */
 100 #define USB_8DEV_STATUSMSG_CRC          0x27  /* CRC Error */
 101
 102 #define USB_8DEV_RP_MASK                0x7F  /* Mask for Receive Error Bit */
 103
 104
 105 /* table of devices that work with this driver */
 106 static const struct usb_device_id usb_8dev_table[] = {
 107         { USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) },
 108         { }                                     /* Terminating entry */
 109 };
 110
 111 MODULE_DEVICE_TABLE(usb, usb_8dev_table);
 112
 113 struct usb_8dev_tx_urb_context {
 114         struct usb_8dev_priv *priv;
 115
 116         u32 echo_index;
 117 };
 118
 119 /* Structure to hold all of our device specific stuff */
 120 struct usb_8dev_priv {
 121         struct can_priv can; /* must be the first member */
 122
 123         struct usb_device *udev;
 124         struct net_device *netdev;
 125
 126         atomic_t active_tx_urbs;
 127         struct usb_anchor tx_submitted;
 128         struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS];
 129
 130         struct usb_anchor rx_submitted;
 131
 132         struct can_berr_counter bec;
 133
 134         u8 *cmd_msg_buffer;
 135
 136         struct mutex usb_8dev_cmd_lock;
 137         void *rxbuf[MAX_RX_URBS];
 138         dma_addr_t rxbuf_dma[MAX_RX_URBS];
 139 };
 140
 141 /* tx frame */
 142 struct __packed usb_8dev_tx_msg {
 143         u8 begin;
 144         u8 flags;       /* RTR and EXT_ID flag */
 145         __be32 id;      /* upper 3 bits not used */
 146         u8 dlc;         /* data length code 0-8 bytes */
 147         u8 data[8];     /* 64-bit data */
 148         u8 end;
 149 };
 150
 151 /* rx frame */
 152 struct __packed usb_8dev_rx_msg {
 153         u8 begin;
 154         u8 type;                /* frame type */
 155         u8 flags;               /* RTR and EXT_ID flag */
 156         __be32 id;              /* upper 3 bits not used */
 157         u8 dlc;                 /* data length code 0-8 bytes */
 158         u8 data[8];             /* 64-bit data */
 159         __be32 timestamp;       /* 32-bit timestamp */
 160         u8 end;
 161 };
 162
 163 /* command frame */
 164 struct __packed usb_8dev_cmd_msg {
 165         u8 begin;
 166         u8 channel;     /* unknown - always 0 */
 167         u8 command;     /* command to execute */
 168         u8 opt1;        /* optional parameter / return value */
 169         u8 opt2;        /* optional parameter 2 */
 170         u8 data[10];    /* optional parameter and data */
 171         u8 end;
 172 };
 173
 174 static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size)
 175 {
 176         int actual_length;
 177
 178         return usb_bulk_msg(priv->udev,
 179                             usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX),
 180                             msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT);
 181 }
 182
 183 static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size,
 184                                 int *actual_length)
 185 {
 186         return usb_bulk_msg(priv->udev,
 187                             usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX),
 188                             msg, size, actual_length, USB_8DEV_CMD_TIMEOUT);
 189 }
 190
 191 /* Send command to device and receive result.
 192  * Command was successful when opt1 = 0.
 193  */
 194 static int usb_8dev_send_cmd(struct usb_8dev_priv *priv,
 195                              struct usb_8dev_cmd_msg *out,
 196                              struct usb_8dev_cmd_msg *in)
 197 {
 198         int err;
 199         int num_bytes_read;
 200         struct net_device *netdev;
 201
 202         netdev = priv->netdev;
 203
 204         out->begin = USB_8DEV_CMD_START;
 205         out->end = USB_8DEV_CMD_END;
 206
 207         mutex_lock(&priv->usb_8dev_cmd_lock);
 208
 209         memcpy(priv->cmd_msg_buffer, out,
 210                 sizeof(struct usb_8dev_cmd_msg));
 211
 212         err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer,
 213                                     sizeof(struct usb_8dev_cmd_msg));
 214         if (err < 0) {
 215                 netdev_err(netdev, "sending command message failed\n");
 216                 goto failed;
 217         }
 218
 219         err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer,
 220                                     sizeof(struct usb_8dev_cmd_msg),
 221                                     &num_bytes_read);
 222         if (err < 0) {
 223                 netdev_err(netdev, "no command message answer\n");
 224                 goto failed;
 225         }
 226
 227         memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg));
 228
 229         if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END ||
 230                         num_bytes_read != 16 || in->opt1 != 0)
 231                 err = -EPROTO;
 232
 233 failed:
 234         mutex_unlock(&priv->usb_8dev_cmd_lock);
 235         return err;
 236 }
 237
 238 /* Send open command to device */
 239 static int usb_8dev_cmd_open(struct usb_8dev_priv *priv)
 240 {
 241         struct can_bittiming *bt = &priv->can.bittiming;
 242         struct usb_8dev_cmd_msg outmsg;
 243         struct usb_8dev_cmd_msg inmsg;
 244         u32 ctrlmode = priv->can.ctrlmode;
 245         u32 flags = USB_8DEV_STATUS_FRAME;
 246         __be32 beflags;
 247         __be16 bebrp;
 248
 249         memset(&outmsg, 0, sizeof(outmsg));
 250         outmsg.command = USB_8DEV_OPEN;
 251         outmsg.opt1 = USB_8DEV_BAUD_MANUAL;
 252         outmsg.data[0] = bt->prop_seg + bt->phase_seg1;
 253         outmsg.data[1] = bt->phase_seg2;
 254         outmsg.data[2] = bt->sjw;
 255
 256         /* BRP */
 257         bebrp = cpu_to_be16((u16)bt->brp);
 258         memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp));
 259
 260         /* flags */
 261         if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
 262                 flags |= USB_8DEV_LOOPBACK;
 263         if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
 264                 flags |= USB_8DEV_SILENT;
 265         if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
 266                 flags |= USB_8DEV_DISABLE_AUTO_RESTRANS;
 267
 268         beflags = cpu_to_be32(flags);
 269         memcpy(&outmsg.data[5], &beflags, sizeof(beflags));
 270
 271         return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
 272 }
 273
 274 /* Send close command to device */
 275 static int usb_8dev_cmd_close(struct usb_8dev_priv *priv)
 276 {
 277         struct usb_8dev_cmd_msg inmsg;
 278         struct usb_8dev_cmd_msg outmsg = {
 279                 .channel = 0,
 280                 .command = USB_8DEV_CLOSE,
 281                 .opt1 = 0,
 282                 .opt2 = 0
 283         };
 284
 285         return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
 286 }
 287
 288 /* Get firmware and hardware version */
 289 static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res)
 290 {
 291         struct usb_8dev_cmd_msg inmsg;
 292         struct usb_8dev_cmd_msg outmsg = {
 293                 .channel = 0,
 294                 .command = USB_8DEV_GET_SOFTW_HARDW_VER,
 295                 .opt1 = 0,
 296                 .opt2 = 0
 297         };
 298
 299         int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg);
 300         if (err)
 301                 return err;
 302
 303         *res = be32_to_cpup((__be32 *)inmsg.data);
 304
 305         return err;
 306 }
 307
 308 /* Set network device mode
 309  *
 310  * Maybe we should leave this function empty, because the device
 311  * set mode variable with open command.
 312  */
 313 static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode)
 314 {
 315         struct usb_8dev_priv *priv = netdev_priv(netdev);
 316         int err = 0;
 317
 318         switch (mode) {
 319         case CAN_MODE_START:
 320                 err = usb_8dev_cmd_open(priv);
 321                 if (err)
 322                         netdev_warn(netdev, "couldn't start device");
 323                 break;
 324
 325         default:
 326                 return -EOPNOTSUPP;
 327         }
 328
 329         return err;
 330 }
 331
 332 /* Read error/status frames */
 333 static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv,
 334                                 struct usb_8dev_rx_msg *msg)
 335 {
 336         struct can_frame *cf;
 337         struct sk_buff *skb;
 338         struct net_device_stats *stats = &priv->netdev->stats;
 339
 340         /* Error message:
 341          * byte 0: Status
 342          * byte 1: bit   7: Receive Passive
 343          * byte 1: bit 0-6: Receive Error Counter
 344          * byte 2: Transmit Error Counter
 345          * byte 3: Always 0 (maybe reserved for future use)
 346          */
 347
 348         u8 state = msg->data[0];
 349         u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK;
 350         u8 txerr = msg->data[2];
 351         int rx_errors = 0;
 352         int tx_errors = 0;
 353
 354         skb = alloc_can_err_skb(priv->netdev, &cf);
 355         if (!skb)
 356                 return;
 357
 358         switch (state) {
 359         case USB_8DEV_STATUSMSG_OK:
 360                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
 361                 cf->can_id |= CAN_ERR_PROT;
 362                 cf->data[2] = CAN_ERR_PROT_ACTIVE;
 363                 break;
 364         case USB_8DEV_STATUSMSG_BUSOFF:
 365                 priv->can.state = CAN_STATE_BUS_OFF;
 366                 cf->can_id |= CAN_ERR_BUSOFF;
 367                 priv->can.can_stats.bus_off++;
 368                 can_bus_off(priv->netdev);
 369                 break;
 370         case USB_8DEV_STATUSMSG_OVERRUN:
 371         case USB_8DEV_STATUSMSG_BUSLIGHT:
 372         case USB_8DEV_STATUSMSG_BUSHEAVY:
 373                 cf->can_id |= CAN_ERR_CRTL;
 374                 break;
 375         default:
 376                 priv->can.state = CAN_STATE_ERROR_WARNING;
 377                 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 378                 priv->can.can_stats.bus_error++;
 379                 break;
 380         }
 381
 382         switch (state) {
 383         case USB_8DEV_STATUSMSG_OK:
 384         case USB_8DEV_STATUSMSG_BUSOFF:
 385                 break;
 386         case USB_8DEV_STATUSMSG_ACK:
 387                 cf->can_id |= CAN_ERR_ACK;
 388                 tx_errors = 1;
 389                 break;
 390         case USB_8DEV_STATUSMSG_CRC:
 391                 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
 392                 rx_errors = 1;
 393                 break;
 394         case USB_8DEV_STATUSMSG_BIT0:
 395                 cf->data[2] |= CAN_ERR_PROT_BIT0;
 396                 tx_errors = 1;
 397                 break;
 398         case USB_8DEV_STATUSMSG_BIT1:
 399                 cf->data[2] |= CAN_ERR_PROT_BIT1;
 400                 tx_errors = 1;
 401                 break;
 402         case USB_8DEV_STATUSMSG_FORM:
 403                 cf->data[2] |= CAN_ERR_PROT_FORM;
 404                 rx_errors = 1;
 405                 break;
 406         case USB_8DEV_STATUSMSG_STUFF:
 407                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 408                 rx_errors = 1;
 409                 break;
 410         case USB_8DEV_STATUSMSG_OVERRUN:
 411                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 412                 stats->rx_over_errors++;
 413                 rx_errors = 1;
 414                 break;
 415         case USB_8DEV_STATUSMSG_BUSLIGHT:
 416                 priv->can.state = CAN_STATE_ERROR_WARNING;
 417                 cf->data[1] = (txerr > rxerr) ?
 418                         CAN_ERR_CRTL_TX_WARNING :
 419                         CAN_ERR_CRTL_RX_WARNING;
 420                 priv->can.can_stats.error_warning++;
 421                 break;
 422         case USB_8DEV_STATUSMSG_BUSHEAVY:
 423                 priv->can.state = CAN_STATE_ERROR_PASSIVE;
 424                 cf->data[1] = (txerr > rxerr) ?
 425                         CAN_ERR_CRTL_TX_PASSIVE :
 426                         CAN_ERR_CRTL_RX_PASSIVE;
 427                 priv->can.can_stats.error_passive++;
 428                 break;
 429         default:
 430                 netdev_warn(priv->netdev,
 431                             "Unknown status/error message (%d)\n", state);
 432                 break;
 433         }
 434
 435         if (tx_errors) {
 436                 cf->data[2] |= CAN_ERR_PROT_TX;
 437                 stats->tx_errors++;
 438         }
 439
 440         if (rx_errors)
 441                 stats->rx_errors++;
 442         if (priv->can.state != CAN_STATE_BUS_OFF) {
 443                 cf->can_id |= CAN_ERR_CNT;
 444                 cf->data[6] = txerr;
 445                 cf->data[7] = rxerr;
 446         }
 447
 448         priv->bec.txerr = txerr;
 449         priv->bec.rxerr = rxerr;
 450
 451         netif_rx(skb);
 452 }
 453
 454 /* Read data and status frames */
 455 static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv,
 456                                 struct usb_8dev_rx_msg *msg)
 457 {
 458         struct can_frame *cf;
 459         struct sk_buff *skb;
 460         struct net_device_stats *stats = &priv->netdev->stats;
 461
 462         if (msg->type == USB_8DEV_TYPE_ERROR_FRAME &&
 463                    msg->flags == USB_8DEV_ERR_FLAG) {
 464                 usb_8dev_rx_err_msg(priv, msg);
 465         } else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) {
 466                 skb = alloc_can_skb(priv->netdev, &cf);
 467                 if (!skb)
 468                         return;
 469
 470                 cf->can_id = be32_to_cpu(msg->id);
 471                 can_frame_set_cc_len(cf, msg->dlc & 0xF, priv->can.ctrlmode);
 472
 473                 if (msg->flags & USB_8DEV_EXTID)
 474                         cf->can_id |= CAN_EFF_FLAG;
 475
 476                 if (msg->flags & USB_8DEV_RTR) {
 477                         cf->can_id |= CAN_RTR_FLAG;
 478                 } else {
 479                         memcpy(cf->data, msg->data, cf->len);
 480                         stats->rx_bytes += cf->len;
 481                 }
 482                 stats->rx_packets++;
 483
 484                 netif_rx(skb);
 485         } else {
 486                 netdev_warn(priv->netdev, "frame type %d unknown",
 487                          msg->type);
 488         }
 489
 490 }
 491
 492 /* Callback for reading data from device
 493  *
 494  * Check urb status, call read function and resubmit urb read operation.
 495  */
 496 static void usb_8dev_read_bulk_callback(struct urb *urb)
 497 {
 498         struct usb_8dev_priv *priv = urb->context;
 499         struct net_device *netdev;
 500         int retval;
 501         int pos = 0;
 502
 503         netdev = priv->netdev;
 504
 505         if (!netif_device_present(netdev))
 506                 return;
 507
 508         switch (urb->status) {
 509         case 0: /* success */
 510                 break;
 511
 512         case -ENOENT:
 513         case -EPIPE:
 514         case -EPROTO:
 515         case -ESHUTDOWN:
 516                 return;
 517
 518         default:
 519                 netdev_info(netdev, "Rx URB aborted (%d)\n",
 520                          urb->status);
 521                 goto resubmit_urb;
 522         }
 523
 524         while (pos < urb->actual_length) {
 525                 struct usb_8dev_rx_msg *msg;
 526
 527                 if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) {
 528                         netdev_err(priv->netdev, "format error\n");
 529                         break;
 530                 }
 531
 532                 msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos);
 533                 usb_8dev_rx_can_msg(priv, msg);
 534
 535                 pos += sizeof(struct usb_8dev_rx_msg);
 536         }
 537
 538 resubmit_urb:
 539         usb_fill_bulk_urb(urb, priv->udev,
 540                           usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX),
 541                           urb->transfer_buffer, RX_BUFFER_SIZE,
 542                           usb_8dev_read_bulk_callback, priv);
 543
 544         retval = usb_submit_urb(urb, GFP_ATOMIC);
 545
 546         if (retval == -ENODEV)
 547                 netif_device_detach(netdev);
 548         else if (retval)
 549                 netdev_err(netdev,
 550                         "failed resubmitting read bulk urb: %d\n", retval);
 551 }
 552
 553 /* Callback handler for write operations
 554  *
 555  * Free allocated buffers, check transmit status and
 556  * calculate statistic.
 557  */
 558 static void usb_8dev_write_bulk_callback(struct urb *urb)
 559 {
 560         struct usb_8dev_tx_urb_context *context = urb->context;
 561         struct usb_8dev_priv *priv;
 562         struct net_device *netdev;
 563
 564         BUG_ON(!context);
 565
 566         priv = context->priv;
 567         netdev = priv->netdev;
 568
 569         /* free up our allocated buffer */
 570         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
 571                           urb->transfer_buffer, urb->transfer_dma);
 572
 573         atomic_dec(&priv->active_tx_urbs);
 574
 575         if (!netif_device_present(netdev))
 576                 return;
 577
 578         if (urb->status)
 579                 netdev_info(netdev, "Tx URB aborted (%d)\n",
 580                          urb->status);
 581
 582         netdev->stats.tx_packets++;
 583         netdev->stats.tx_bytes += can_get_echo_skb(netdev, context->echo_index, NULL);
 584
 585         /* Release context */
 586         context->echo_index = MAX_TX_URBS;
 587
 588         netif_wake_queue(netdev);
 589 }
 590
 591 /* Send data to device */
 592 static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb,
 593                                       struct net_device *netdev)
 594 {
 595         struct usb_8dev_priv *priv = netdev_priv(netdev);
 596         struct net_device_stats *stats = &netdev->stats;
 597         struct can_frame *cf = (struct can_frame *) skb->data;
 598         struct usb_8dev_tx_msg *msg;
 599         struct urb *urb;
 600         struct usb_8dev_tx_urb_context *context = NULL;
 601         u8 *buf;
 602         int i, err;
 603         size_t size = sizeof(struct usb_8dev_tx_msg);
 604
 605         if (can_dropped_invalid_skb(netdev, skb))
 606                 return NETDEV_TX_OK;
 607
 608         /* create a URB, and a buffer for it, and copy the data to the URB */
 609         urb = usb_alloc_urb(0, GFP_ATOMIC);
 610         if (!urb)
 611                 goto nomem;
 612
 613         buf = usb_alloc_coherent(priv->udev, size, GFP_ATOMIC,
 614                                  &urb->transfer_dma);
 615         if (!buf) {
 616                 netdev_err(netdev, "No memory left for USB buffer\n");
 617                 goto nomembuf;
 618         }
 619
 620         memset(buf, 0, size);
 621
 622         msg = (struct usb_8dev_tx_msg *)buf;
 623         msg->begin = USB_8DEV_DATA_START;
 624         msg->flags = 0x00;
 625
 626         if (cf->can_id & CAN_RTR_FLAG)
 627                 msg->flags |= USB_8DEV_RTR;
 628
 629         if (cf->can_id & CAN_EFF_FLAG)
 630                 msg->flags |= USB_8DEV_EXTID;
 631
 632         msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK);
 633         msg->dlc = can_get_cc_dlc(cf, priv->can.ctrlmode);
 634         memcpy(msg->data, cf->data, cf->len);
 635         msg->end = USB_8DEV_DATA_END;
 636
 637         for (i = 0; i < MAX_TX_URBS; i++) {
 638                 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
 639                         context = &priv->tx_contexts[i];
 640                         break;
 641                 }
 642         }
 643
 644         /* May never happen! When this happens we'd more URBs in flight as
 645          * allowed (MAX_TX_URBS).
 646          */
 647         if (!context)
 648                 goto nofreecontext;
 649
 650         context->priv = priv;
 651         context->echo_index = i;
 652
 653         usb_fill_bulk_urb(urb, priv->udev,
 654                           usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX),
 655                           buf, size, usb_8dev_write_bulk_callback, context);
 656         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 657         usb_anchor_urb(urb, &priv->tx_submitted);
 658
 659         can_put_echo_skb(skb, netdev, context->echo_index, 0);
 660
 661         atomic_inc(&priv->active_tx_urbs);
 662
 663         err = usb_submit_urb(urb, GFP_ATOMIC);
 664         if (unlikely(err)) {
 665                 can_free_echo_skb(netdev, context->echo_index, NULL);
 666
 667                 usb_unanchor_urb(urb);
 668                 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
 669
 670                 atomic_dec(&priv->active_tx_urbs);
 671
 672                 if (err == -ENODEV)
 673                         netif_device_detach(netdev);
 674                 else
 675                         netdev_warn(netdev, "failed tx_urb %d\n", err);
 676                 stats->tx_dropped++;
 677         } else if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
 678                 /* Slow down tx path */
 679                 netif_stop_queue(netdev);
 680
 681         /* Release our reference to this URB, the USB core will eventually free
 682          * it entirely.
 683          */
 684         usb_free_urb(urb);
 685
 686         return NETDEV_TX_OK;
 687
 688 nofreecontext:
 689         usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
 690         usb_free_urb(urb);
 691
 692         netdev_warn(netdev, "couldn't find free context");
 693
 694         return NETDEV_TX_BUSY;
 695
 696 nomembuf:
 697         usb_free_urb(urb);
 698
 699 nomem:
 700         dev_kfree_skb(skb);
 701         stats->tx_dropped++;
 702
 703         return NETDEV_TX_OK;
 704 }
 705
 706 static int usb_8dev_get_berr_counter(const struct net_device *netdev,
 707                                      struct can_berr_counter *bec)
 708 {
 709         struct usb_8dev_priv *priv = netdev_priv(netdev);
 710
 711         bec->txerr = priv->bec.txerr;
 712         bec->rxerr = priv->bec.rxerr;
 713
 714         return 0;
 715 }
 716
 717 /* Start USB device */
 718 static int usb_8dev_start(struct usb_8dev_priv *priv)
 719 {
 720         struct net_device *netdev = priv->netdev;
 721         int err, i;
 722
 723         for (i = 0; i < MAX_RX_URBS; i++) {
 724                 struct urb *urb = NULL;
 725                 u8 *buf;
 726                 dma_addr_t buf_dma;
 727
 728                 /* create a URB, and a buffer for it */
 729                 urb = usb_alloc_urb(0, GFP_KERNEL);
 730                 if (!urb) {
 731                         err = -ENOMEM;
 732                         break;
 733                 }
 734
 735                 buf = usb_alloc_coherent(priv->udev, RX_BUFFER_SIZE, GFP_KERNEL,
 736                                          &buf_dma);
 737                 if (!buf) {
 738                         netdev_err(netdev, "No memory left for USB buffer\n");
 739                         usb_free_urb(urb);
 740                         err = -ENOMEM;
 741                         break;
 742                 }
 743
 744                 urb->transfer_dma = buf_dma;
 745
 746                 usb_fill_bulk_urb(urb, priv->udev,
 747                                   usb_rcvbulkpipe(priv->udev,
 748                                                   USB_8DEV_ENDP_DATA_RX),
 749                                   buf, RX_BUFFER_SIZE,
 750                                   usb_8dev_read_bulk_callback, priv);
 751                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 752                 usb_anchor_urb(urb, &priv->rx_submitted);
 753
 754                 err = usb_submit_urb(urb, GFP_KERNEL);
 755                 if (err) {
 756                         usb_unanchor_urb(urb);
 757                         usb_free_coherent(priv->udev, RX_BUFFER_SIZE, buf,
 758                                           urb->transfer_dma);
 759                         usb_free_urb(urb);
 760                         break;
 761                 }
 762
 763                 priv->rxbuf[i] = buf;
 764                 priv->rxbuf_dma[i] = buf_dma;
 765
 766                 /* Drop reference, USB core will take care of freeing it */
 767                 usb_free_urb(urb);
 768         }
 769
 770         /* Did we submit any URBs */
 771         if (i == 0) {
 772                 netdev_warn(netdev, "couldn't setup read URBs\n");
 773                 return err;
 774         }
 775
 776         /* Warn if we've couldn't transmit all the URBs */
 777         if (i < MAX_RX_URBS)
 778                 netdev_warn(netdev, "rx performance may be slow\n");
 779
 780         err = usb_8dev_cmd_open(priv);
 781         if (err)
 782                 goto failed;
 783
 784         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 785
 786         return 0;
 787
 788 failed:
 789         if (err == -ENODEV)
 790                 netif_device_detach(priv->netdev);
 791
 792         netdev_warn(netdev, "couldn't submit control: %d\n", err);
 793
 794         return err;
 795 }
 796
 797 /* Open USB device */
 798 static int usb_8dev_open(struct net_device *netdev)
 799 {
 800         struct usb_8dev_priv *priv = netdev_priv(netdev);
 801         int err;
 802
 803         /* common open */
 804         err = open_candev(netdev);
 805         if (err)
 806                 return err;
 807
 808         /* finally start device */
 809         err = usb_8dev_start(priv);
 810         if (err) {
 811                 if (err == -ENODEV)
 812                         netif_device_detach(priv->netdev);
 813
 814                 netdev_warn(netdev, "couldn't start device: %d\n",
 815                          err);
 816
 817                 close_candev(netdev);
 818
 819                 return err;
 820         }
 821
 822         netif_start_queue(netdev);
 823
 824         return 0;
 825 }
 826
 827 static void unlink_all_urbs(struct usb_8dev_priv *priv)
 828 {
 829         int i;
 830
 831         usb_kill_anchored_urbs(&priv->rx_submitted);
 832
 833         for (i = 0; i < MAX_RX_URBS; ++i)
 834                 usb_free_coherent(priv->udev, RX_BUFFER_SIZE,
 835                                   priv->rxbuf[i], priv->rxbuf_dma[i]);
 836
 837         usb_kill_anchored_urbs(&priv->tx_submitted);
 838         atomic_set(&priv->active_tx_urbs, 0);
 839
 840         for (i = 0; i < MAX_TX_URBS; i++)
 841                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
 842 }
 843
 844 /* Close USB device */
 845 static int usb_8dev_close(struct net_device *netdev)
 846 {
 847         struct usb_8dev_priv *priv = netdev_priv(netdev);
 848         int err = 0;
 849
 850         /* Send CLOSE command to CAN controller */
 851         err = usb_8dev_cmd_close(priv);
 852         if (err)
 853                 netdev_warn(netdev, "couldn't stop device");
 854
 855         priv->can.state = CAN_STATE_STOPPED;
 856
 857         netif_stop_queue(netdev);
 858
 859         /* Stop polling */
 860         unlink_all_urbs(priv);
 861
 862         close_candev(netdev);
 863
 864         return err;
 865 }
 866
 867 static const struct net_device_ops usb_8dev_netdev_ops = {
 868         .ndo_open = usb_8dev_open,
 869         .ndo_stop = usb_8dev_close,
 870         .ndo_start_xmit = usb_8dev_start_xmit,
 871         .ndo_change_mtu = can_change_mtu,
 872 };
 873
 874 static const struct ethtool_ops usb_8dev_ethtool_ops = {
 875         .get_ts_info = ethtool_op_get_ts_info,
 876 };
 877
 878 static const struct can_bittiming_const usb_8dev_bittiming_const = {
 879         .name = KBUILD_MODNAME,
 880         .tseg1_min = 1,
 881         .tseg1_max = 16,
 882         .tseg2_min = 1,
 883         .tseg2_max = 8,
 884         .sjw_max = 4,
 885         .brp_min = 1,
 886         .brp_max = 1024,
 887         .brp_inc = 1,
 888 };
 889
 890 /* Probe USB device
 891  *
 892  * Check device and firmware.
 893  * Set supported modes and bittiming constants.
 894  * Allocate some memory.
 895  */
 896 static int usb_8dev_probe(struct usb_interface *intf,
 897                          const struct usb_device_id *id)
 898 {
 899         struct net_device *netdev;
 900         struct usb_8dev_priv *priv;
 901         int i, err = -ENOMEM;
 902         u32 version;
 903         char buf[18];
 904         struct usb_device *usbdev = interface_to_usbdev(intf);
 905
 906         /* product id looks strange, better we also check iProduct string */
 907         if (usb_string(usbdev, usbdev->descriptor.iProduct, buf,
 908                        sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter")) {
 909                 dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n");
 910                 return -ENODEV;
 911         }
 912
 913         netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS);
 914         if (!netdev) {
 915                 dev_err(&intf->dev, "Couldn't alloc candev\n");
 916                 return -ENOMEM;
 917         }
 918
 919         priv = netdev_priv(netdev);
 920
 921         priv->udev = usbdev;
 922         priv->netdev = netdev;
 923
 924         priv->can.state = CAN_STATE_STOPPED;
 925         priv->can.clock.freq = USB_8DEV_ABP_CLOCK;
 926         priv->can.bittiming_const = &usb_8dev_bittiming_const;
 927         priv->can.do_set_mode = usb_8dev_set_mode;
 928         priv->can.do_get_berr_counter = usb_8dev_get_berr_counter;
 929         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
 930                                       CAN_CTRLMODE_LISTENONLY |
 931                                       CAN_CTRLMODE_ONE_SHOT |
 932                                       CAN_CTRLMODE_CC_LEN8_DLC;
 933
 934         netdev->netdev_ops = &usb_8dev_netdev_ops;
 935         netdev->ethtool_ops = &usb_8dev_ethtool_ops;
 936
 937         netdev->flags |= IFF_ECHO; /* we support local echo */
 938
 939         init_usb_anchor(&priv->rx_submitted);
 940
 941         init_usb_anchor(&priv->tx_submitted);
 942         atomic_set(&priv->active_tx_urbs, 0);
 943
 944         for (i = 0; i < MAX_TX_URBS; i++)
 945                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
 946
 947         priv->cmd_msg_buffer = devm_kzalloc(&intf->dev, sizeof(struct usb_8dev_cmd_msg),
 948                                             GFP_KERNEL);
 949         if (!priv->cmd_msg_buffer)
 950                 goto cleanup_candev;
 951
 952         usb_set_intfdata(intf, priv);
 953
 954         SET_NETDEV_DEV(netdev, &intf->dev);
 955
 956         mutex_init(&priv->usb_8dev_cmd_lock);
 957
 958         err = register_candev(netdev);
 959         if (err) {
 960                 netdev_err(netdev,
 961                         "couldn't register CAN device: %d\n", err);
 962                 goto cleanup_candev;
 963         }
 964
 965         err = usb_8dev_cmd_version(priv, &version);
 966         if (err) {
 967                 netdev_err(netdev, "can't get firmware version\n");
 968                 goto cleanup_unregister_candev;
 969         } else {
 970                 netdev_info(netdev,
 971                          "firmware: %d.%d, hardware: %d.%d\n",
 972                          (version>>24) & 0xff, (version>>16) & 0xff,
 973                          (version>>8) & 0xff, version & 0xff);
 974         }
 975
 976         return 0;
 977
 978 cleanup_unregister_candev:
 979         unregister_netdev(priv->netdev);
 980
 981 cleanup_candev:
 982         free_candev(netdev);
 983
 984         return err;
 985
 986 }
 987
 988 /* Called by the usb core when driver is unloaded or device is removed */
 989 static void usb_8dev_disconnect(struct usb_interface *intf)
 990 {
 991         struct usb_8dev_priv *priv = usb_get_intfdata(intf);
 992
 993         usb_set_intfdata(intf, NULL);
 994
 995         if (priv) {
 996                 netdev_info(priv->netdev, "device disconnected\n");
 997
 998                 unregister_netdev(priv->netdev);
 999                 unlink_all_urbs(priv);
1000                 free_candev(priv->netdev);
1001         }
1002
1003 }
1004
1005 static struct usb_driver usb_8dev_driver = {
1006         .name =         KBUILD_MODNAME,
1007         .probe =        usb_8dev_probe,
1008         .disconnect =   usb_8dev_disconnect,
1009         .id_table =     usb_8dev_table,
1010 };
1011
1012 module_usb_driver(usb_8dev_driver);
1013
1014 MODULE_AUTHOR("Bernd Krumboeck <[email protected]>");
1015 MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces");
1016 MODULE_LICENSE("GPL v2");