drivers/net/can/usb/esd_usb2.c

   1 /*
   2  * CAN driver for esd CAN-USB/2 and CAN-USB/Micro
   3  *
   4  * Copyright (C) 2010-2012 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published
   8  * by the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19 #include <linux/signal.h>
  20 #include <linux/slab.h>
  21 #include <linux/module.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/usb.h>
  24
  25 #include <linux/can.h>
  26 #include <linux/can/dev.h>
  27 #include <linux/can/error.h>
  28
  29 MODULE_AUTHOR("Matthias Fuchs <matthias.fuchs@esd.eu>");
  30 MODULE_DESCRIPTION("CAN driver for esd CAN-USB/2 and CAN-USB/Micro interfaces");
  31 MODULE_LICENSE("GPL v2");
  32
  33 /* Define these values to match your devices */
  34 #define USB_ESDGMBH_VENDOR_ID   0x0ab4
  35 #define USB_CANUSB2_PRODUCT_ID  0x0010
  36 #define USB_CANUSBM_PRODUCT_ID  0x0011
  37
  38 #define ESD_USB2_CAN_CLOCK      60000000
  39 #define ESD_USBM_CAN_CLOCK      36000000
  40 #define ESD_USB2_MAX_NETS       2
  41
  42 /* USB2 commands */
  43 #define CMD_VERSION             1 /* also used for VERSION_REPLY */
  44 #define CMD_CAN_RX              2 /* device to host only */
  45 #define CMD_CAN_TX              3 /* also used for TX_DONE */
  46 #define CMD_SETBAUD             4 /* also used for SETBAUD_REPLY */
  47 #define CMD_TS                  5 /* also used for TS_REPLY */
  48 #define CMD_IDADD               6 /* also used for IDADD_REPLY */
  49
  50 /* esd CAN message flags - dlc field */
  51 #define ESD_RTR                 0x10
  52
  53 /* esd CAN message flags - id field */
  54 #define ESD_EXTID               0x20000000
  55 #define ESD_EVENT               0x40000000
  56 #define ESD_IDMASK              0x1fffffff
  57
  58 /* esd CAN event ids used by this driver */
  59 #define ESD_EV_CAN_ERROR_EXT    2
  60
  61 /* baudrate message flags */
  62 #define ESD_USB2_UBR            0x80000000
  63 #define ESD_USB2_LOM            0x40000000
  64 #define ESD_USB2_NO_BAUDRATE    0x7fffffff
  65 #define ESD_USB2_TSEG1_MIN      1
  66 #define ESD_USB2_TSEG1_MAX      16
  67 #define ESD_USB2_TSEG1_SHIFT    16
  68 #define ESD_USB2_TSEG2_MIN      1
  69 #define ESD_USB2_TSEG2_MAX      8
  70 #define ESD_USB2_TSEG2_SHIFT    20
  71 #define ESD_USB2_SJW_MAX        4
  72 #define ESD_USB2_SJW_SHIFT      14
  73 #define ESD_USBM_SJW_SHIFT      24
  74 #define ESD_USB2_BRP_MIN        1
  75 #define ESD_USB2_BRP_MAX        1024
  76 #define ESD_USB2_BRP_INC        1
  77 #define ESD_USB2_3_SAMPLES      0x00800000
  78
  79 /* esd IDADD message */
  80 #define ESD_ID_ENABLE           0x80
  81 #define ESD_MAX_ID_SEGMENT      64
  82
  83 /* SJA1000 ECC register (emulated by usb2 firmware) */
  84 #define SJA1000_ECC_SEG         0x1F
  85 #define SJA1000_ECC_DIR         0x20
  86 #define SJA1000_ECC_ERR         0x06
  87 #define SJA1000_ECC_BIT         0x00
  88 #define SJA1000_ECC_FORM        0x40
  89 #define SJA1000_ECC_STUFF       0x80
  90 #define SJA1000_ECC_MASK        0xc0
  91
  92 /* esd bus state event codes */
  93 #define ESD_BUSSTATE_MASK       0xc0
  94 #define ESD_BUSSTATE_WARN       0x40
  95 #define ESD_BUSSTATE_ERRPASSIVE 0x80
  96 #define ESD_BUSSTATE_BUSOFF     0xc0
  97
  98 #define RX_BUFFER_SIZE          1024
  99 #define MAX_RX_URBS             4
 100 #define MAX_TX_URBS             16 /* must be power of 2 */
 101
 102 struct header_msg {
 103         u8 len; /* len is always the total message length in 32bit words */
 104         u8 cmd;
 105         u8 rsvd[2];
 106 };
 107
 108 struct version_msg {
 109         u8 len;
 110         u8 cmd;
 111         u8 rsvd;
 112         u8 flags;
 113         __le32 drv_version;
 114 };
 115
 116 struct version_reply_msg {
 117         u8 len;
 118         u8 cmd;
 119         u8 nets;
 120         u8 features;
 121         __le32 version;
 122         u8 name[16];
 123         __le32 rsvd;
 124         __le32 ts;
 125 };
 126
 127 struct rx_msg {
 128         u8 len;
 129         u8 cmd;
 130         u8 net;
 131         u8 dlc;
 132         __le32 ts;
 133         __le32 id; /* upper 3 bits contain flags */
 134         u8 data[8];
 135 };
 136
 137 struct tx_msg {
 138         u8 len;
 139         u8 cmd;
 140         u8 net;
 141         u8 dlc;
 142         u32 hnd;        /* opaque handle, not used by device */
 143         __le32 id; /* upper 3 bits contain flags */
 144         u8 data[8];
 145 };
 146
 147 struct tx_done_msg {
 148         u8 len;
 149         u8 cmd;
 150         u8 net;
 151         u8 status;
 152         u32 hnd;        /* opaque handle, not used by device */
 153         __le32 ts;
 154 };
 155
 156 struct id_filter_msg {
 157         u8 len;
 158         u8 cmd;
 159         u8 net;
 160         u8 option;
 161         __le32 mask[ESD_MAX_ID_SEGMENT + 1];
 162 };
 163
 164 struct set_baudrate_msg {
 165         u8 len;
 166         u8 cmd;
 167         u8 net;
 168         u8 rsvd;
 169         __le32 baud;
 170 };
 171
 172 /* Main message type used between library and application */
 173 struct __attribute__ ((packed)) esd_usb2_msg {
 174         union {
 175                 struct header_msg hdr;
 176                 struct version_msg version;
 177                 struct version_reply_msg version_reply;
 178                 struct rx_msg rx;
 179                 struct tx_msg tx;
 180                 struct tx_done_msg txdone;
 181                 struct set_baudrate_msg setbaud;
 182                 struct id_filter_msg filter;
 183         } msg;
 184 };
 185
 186 static struct usb_device_id esd_usb2_table[] = {
 187         {USB_DEVICE(USB_ESDGMBH_VENDOR_ID, USB_CANUSB2_PRODUCT_ID)},
 188         {USB_DEVICE(USB_ESDGMBH_VENDOR_ID, USB_CANUSBM_PRODUCT_ID)},
 189         {}
 190 };
 191 MODULE_DEVICE_TABLE(usb, esd_usb2_table);
 192
 193 struct esd_usb2_net_priv;
 194
 195 struct esd_tx_urb_context {
 196         struct esd_usb2_net_priv *priv;
 197         u32 echo_index;
 198         int dlc;
 199 };
 200
 201 struct esd_usb2 {
 202         struct usb_device *udev;
 203         struct esd_usb2_net_priv *nets[ESD_USB2_MAX_NETS];
 204
 205         struct usb_anchor rx_submitted;
 206
 207         int net_count;
 208         u32 version;
 209         int rxinitdone;
 210         void *rxbuf[MAX_RX_URBS];
 211         dma_addr_t rxbuf_dma[MAX_RX_URBS];
 212 };
 213
 214 struct esd_usb2_net_priv {
 215         struct can_priv can; /* must be the first member */
 216
 217         atomic_t active_tx_jobs;
 218         struct usb_anchor tx_submitted;
 219         struct esd_tx_urb_context tx_contexts[MAX_TX_URBS];
 220
 221         struct esd_usb2 *usb2;
 222         struct net_device *netdev;
 223         int index;
 224         u8 old_state;
 225         struct can_berr_counter bec;
 226 };
 227
 228 static void esd_usb2_rx_event(struct esd_usb2_net_priv *priv,
 229                               struct esd_usb2_msg *msg)
 230 {
 231         struct net_device_stats *stats = &priv->netdev->stats;
 232         struct can_frame *cf;
 233         struct sk_buff *skb;
 234         u32 id = le32_to_cpu(msg->msg.rx.id) & ESD_IDMASK;
 235
 236         if (id == ESD_EV_CAN_ERROR_EXT) {
 237                 u8 state = msg->msg.rx.data[0];
 238                 u8 ecc = msg->msg.rx.data[1];
 239                 u8 rxerr = msg->msg.rx.data[2];
 240                 u8 txerr = msg->msg.rx.data[3];
 241
 242                 skb = alloc_can_err_skb(priv->netdev, &cf);
 243                 if (skb == NULL) {
 244                         stats->rx_dropped++;
 245                         return;
 246                 }
 247
 248                 if (state != priv->old_state) {
 249                         priv->old_state = state;
 250
 251                         switch (state & ESD_BUSSTATE_MASK) {
 252                         case ESD_BUSSTATE_BUSOFF:
 253                                 priv->can.state = CAN_STATE_BUS_OFF;
 254                                 cf->can_id |= CAN_ERR_BUSOFF;
 255                                 priv->can.can_stats.bus_off++;
 256                                 can_bus_off(priv->netdev);
 257                                 break;
 258                         case ESD_BUSSTATE_WARN:
 259                                 priv->can.state = CAN_STATE_ERROR_WARNING;
 260                                 priv->can.can_stats.error_warning++;
 261                                 break;
 262                         case ESD_BUSSTATE_ERRPASSIVE:
 263                                 priv->can.state = CAN_STATE_ERROR_PASSIVE;
 264                                 priv->can.can_stats.error_passive++;
 265                                 break;
 266                         default:
 267                                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
 268                                 break;
 269                         }
 270                 } else {
 271                         priv->can.can_stats.bus_error++;
 272                         stats->rx_errors++;
 273
 274                         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 275
 276                         switch (ecc & SJA1000_ECC_MASK) {
 277                         case SJA1000_ECC_BIT:
 278                                 cf->data[2] |= CAN_ERR_PROT_BIT;
 279                                 break;
 280                         case SJA1000_ECC_FORM:
 281                                 cf->data[2] |= CAN_ERR_PROT_FORM;
 282                                 break;
 283                         case SJA1000_ECC_STUFF:
 284                                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 285                                 break;
 286                         default:
 287                                 cf->data[3] = ecc & SJA1000_ECC_SEG;
 288                                 break;
 289                         }
 290
 291                         /* Error occurred during transmission? */
 292                         if (!(ecc & SJA1000_ECC_DIR))
 293                                 cf->data[2] |= CAN_ERR_PROT_TX;
 294
 295                         if (priv->can.state == CAN_STATE_ERROR_WARNING ||
 296                             priv->can.state == CAN_STATE_ERROR_PASSIVE) {
 297                                 cf->data[1] = (txerr > rxerr) ?
 298                                         CAN_ERR_CRTL_TX_PASSIVE :
 299                                         CAN_ERR_CRTL_RX_PASSIVE;
 300                         }
 301                         cf->data[6] = txerr;
 302                         cf->data[7] = rxerr;
 303                 }
 304
 305                 priv->bec.txerr = txerr;
 306                 priv->bec.rxerr = rxerr;
 307
 308                 stats->rx_packets++;
 309                 stats->rx_bytes += cf->can_dlc;
 310                 netif_rx(skb);
 311         }
 312 }
 313
 314 static void esd_usb2_rx_can_msg(struct esd_usb2_net_priv *priv,
 315                                 struct esd_usb2_msg *msg)
 316 {
 317         struct net_device_stats *stats = &priv->netdev->stats;
 318         struct can_frame *cf;
 319         struct sk_buff *skb;
 320         int i;
 321         u32 id;
 322
 323         if (!netif_device_present(priv->netdev))
 324                 return;
 325
 326         id = le32_to_cpu(msg->msg.rx.id);
 327
 328         if (id & ESD_EVENT) {
 329                 esd_usb2_rx_event(priv, msg);
 330         } else {
 331                 skb = alloc_can_skb(priv->netdev, &cf);
 332                 if (skb == NULL) {
 333                         stats->rx_dropped++;
 334                         return;
 335                 }
 336
 337                 cf->can_id = id & ESD_IDMASK;
 338                 cf->can_dlc = get_can_dlc(msg->msg.rx.dlc & ~ESD_RTR);
 339
 340                 if (id & ESD_EXTID)
 341                         cf->can_id |= CAN_EFF_FLAG;
 342
 343                 if (msg->msg.rx.dlc & ESD_RTR) {
 344                         cf->can_id |= CAN_RTR_FLAG;
 345                 } else {
 346                         for (i = 0; i < cf->can_dlc; i++)
 347                                 cf->data[i] = msg->msg.rx.data[i];
 348                 }
 349
 350                 stats->rx_packets++;
 351                 stats->rx_bytes += cf->can_dlc;
 352                 netif_rx(skb);
 353         }
 354
 355         return;
 356 }
 357
 358 static void esd_usb2_tx_done_msg(struct esd_usb2_net_priv *priv,
 359                                  struct esd_usb2_msg *msg)
 360 {
 361         struct net_device_stats *stats = &priv->netdev->stats;
 362         struct net_device *netdev = priv->netdev;
 363         struct esd_tx_urb_context *context;
 364
 365         if (!netif_device_present(netdev))
 366                 return;
 367
 368         context = &priv->tx_contexts[msg->msg.txdone.hnd & (MAX_TX_URBS - 1)];
 369
 370         if (!msg->msg.txdone.status) {
 371                 stats->tx_packets++;
 372                 stats->tx_bytes += context->dlc;
 373                 can_get_echo_skb(netdev, context->echo_index);
 374         } else {
 375                 stats->tx_errors++;
 376                 can_free_echo_skb(netdev, context->echo_index);
 377         }
 378
 379         /* Release context */
 380         context->echo_index = MAX_TX_URBS;
 381         atomic_dec(&priv->active_tx_jobs);
 382
 383         netif_wake_queue(netdev);
 384 }
 385
 386 static void esd_usb2_read_bulk_callback(struct urb *urb)
 387 {
 388         struct esd_usb2 *dev = urb->context;
 389         int retval;
 390         int pos = 0;
 391         int i;
 392
 393         switch (urb->status) {
 394         case 0: /* success */
 395                 break;
 396
 397         case -ENOENT:
 398         case -EPIPE:
 399         case -EPROTO:
 400         case -ESHUTDOWN:
 401                 return;
 402
 403         default:
 404                 dev_info(dev->udev->dev.parent,
 405                          "Rx URB aborted (%d)\n", urb->status);
 406                 goto resubmit_urb;
 407         }
 408
 409         while (pos < urb->actual_length) {
 410                 struct esd_usb2_msg *msg;
 411
 412                 msg = (struct esd_usb2_msg *)(urb->transfer_buffer + pos);
 413
 414                 switch (msg->msg.hdr.cmd) {
 415                 case CMD_CAN_RX:
 416                         if (msg->msg.rx.net >= dev->net_count) {
 417                                 dev_err(dev->udev->dev.parent, "format error\n");
 418                                 break;
 419                         }
 420
 421                         esd_usb2_rx_can_msg(dev->nets[msg->msg.rx.net], msg);
 422                         break;
 423
 424                 case CMD_CAN_TX:
 425                         if (msg->msg.txdone.net >= dev->net_count) {
 426                                 dev_err(dev->udev->dev.parent, "format error\n");
 427                                 break;
 428                         }
 429
 430                         esd_usb2_tx_done_msg(dev->nets[msg->msg.txdone.net],
 431                                              msg);
 432                         break;
 433                 }
 434
 435                 pos += msg->msg.hdr.len << 2;
 436
 437                 if (pos > urb->actual_length) {
 438                         dev_err(dev->udev->dev.parent, "format error\n");
 439                         break;
 440                 }
 441         }
 442
 443 resubmit_urb:
 444         usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 445                           urb->transfer_buffer, RX_BUFFER_SIZE,
 446                           esd_usb2_read_bulk_callback, dev);
 447
 448         retval = usb_submit_urb(urb, GFP_ATOMIC);
 449         if (retval == -ENODEV) {
 450                 for (i = 0; i < dev->net_count; i++) {
 451                         if (dev->nets[i])
 452                                 netif_device_detach(dev->nets[i]->netdev);
 453                 }
 454         } else if (retval) {
 455                 dev_err(dev->udev->dev.parent,
 456                         "failed resubmitting read bulk urb: %d\n", retval);
 457         }
 458
 459         return;
 460 }
 461
 462 /*
 463  * callback for bulk IN urb
 464  */
 465 static void esd_usb2_write_bulk_callback(struct urb *urb)
 466 {
 467         struct esd_tx_urb_context *context = urb->context;
 468         struct esd_usb2_net_priv *priv;
 469         struct net_device *netdev;
 470         size_t size = sizeof(struct esd_usb2_msg);
 471
 472         WARN_ON(!context);
 473
 474         priv = context->priv;
 475         netdev = priv->netdev;
 476
 477         /* free up our allocated buffer */
 478         usb_free_coherent(urb->dev, size,
 479                           urb->transfer_buffer, urb->transfer_dma);
 480
 481         if (!netif_device_present(netdev))
 482                 return;
 483
 484         if (urb->status)
 485                 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
 486
 487         netif_trans_update(netdev);
 488 }
 489
 490 static ssize_t show_firmware(struct device *d,
 491                              struct device_attribute *attr, char *buf)
 492 {
 493         struct usb_interface *intf = to_usb_interface(d);
 494         struct esd_usb2 *dev = usb_get_intfdata(intf);
 495
 496         return sprintf(buf, "%d.%d.%d\n",
 497                        (dev->version >> 12) & 0xf,
 498                        (dev->version >> 8) & 0xf,
 499                        dev->version & 0xff);
 500 }
 501 static DEVICE_ATTR(firmware, S_IRUGO, show_firmware, NULL);
 502
 503 static ssize_t show_hardware(struct device *d,
 504                              struct device_attribute *attr, char *buf)
 505 {
 506         struct usb_interface *intf = to_usb_interface(d);
 507         struct esd_usb2 *dev = usb_get_intfdata(intf);
 508
 509         return sprintf(buf, "%d.%d.%d\n",
 510                        (dev->version >> 28) & 0xf,
 511                        (dev->version >> 24) & 0xf,
 512                        (dev->version >> 16) & 0xff);
 513 }
 514 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL);
 515
 516 static ssize_t show_nets(struct device *d,
 517                          struct device_attribute *attr, char *buf)
 518 {
 519         struct usb_interface *intf = to_usb_interface(d);
 520         struct esd_usb2 *dev = usb_get_intfdata(intf);
 521
 522         return sprintf(buf, "%d", dev->net_count);
 523 }
 524 static DEVICE_ATTR(nets, S_IRUGO, show_nets, NULL);
 525
 526 static int esd_usb2_send_msg(struct esd_usb2 *dev, struct esd_usb2_msg *msg)
 527 {
 528         int actual_length;
 529
 530         return usb_bulk_msg(dev->udev,
 531                             usb_sndbulkpipe(dev->udev, 2),
 532                             msg,
 533                             msg->msg.hdr.len << 2,
 534                             &actual_length,
 535                             1000);
 536 }
 537
 538 static int esd_usb2_wait_msg(struct esd_usb2 *dev,
 539                              struct esd_usb2_msg *msg)
 540 {
 541         int actual_length;
 542
 543         return usb_bulk_msg(dev->udev,
 544                             usb_rcvbulkpipe(dev->udev, 1),
 545                             msg,
 546                             sizeof(*msg),
 547                             &actual_length,
 548                             1000);
 549 }
 550
 551 static int esd_usb2_setup_rx_urbs(struct esd_usb2 *dev)
 552 {
 553         int i, err = 0;
 554
 555         if (dev->rxinitdone)
 556                 return 0;
 557
 558         for (i = 0; i < MAX_RX_URBS; i++) {
 559                 struct urb *urb = NULL;
 560                 u8 *buf = NULL;
 561                 dma_addr_t buf_dma;
 562
 563                 /* create a URB, and a buffer for it */
 564                 urb = usb_alloc_urb(0, GFP_KERNEL);
 565                 if (!urb) {
 566                         err = -ENOMEM;
 567                         break;
 568                 }
 569
 570                 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL,
 571                                          &buf_dma);
 572                 if (!buf) {
 573                         dev_warn(dev->udev->dev.parent,
 574                                  "No memory left for USB buffer\n");
 575                         err = -ENOMEM;
 576                         goto freeurb;
 577                 }
 578
 579                 urb->transfer_dma = buf_dma;
 580
 581                 usb_fill_bulk_urb(urb, dev->udev,
 582                                   usb_rcvbulkpipe(dev->udev, 1),
 583                                   buf, RX_BUFFER_SIZE,
 584                                   esd_usb2_read_bulk_callback, dev);
 585                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 586                 usb_anchor_urb(urb, &dev->rx_submitted);
 587
 588                 err = usb_submit_urb(urb, GFP_KERNEL);
 589                 if (err) {
 590                         usb_unanchor_urb(urb);
 591                         usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
 592                                           urb->transfer_dma);
 593                         goto freeurb;
 594                 }
 595
 596                 dev->rxbuf[i] = buf;
 597                 dev->rxbuf_dma[i] = buf_dma;
 598
 599 freeurb:
 600                 /* Drop reference, USB core will take care of freeing it */
 601                 usb_free_urb(urb);
 602                 if (err)
 603                         break;
 604         }
 605
 606         /* Did we submit any URBs */
 607         if (i == 0) {
 608                 dev_err(dev->udev->dev.parent, "couldn't setup read URBs\n");
 609                 return err;
 610         }
 611
 612         /* Warn if we've couldn't transmit all the URBs */
 613         if (i < MAX_RX_URBS) {
 614                 dev_warn(dev->udev->dev.parent,
 615                          "rx performance may be slow\n");
 616         }
 617
 618         dev->rxinitdone = 1;
 619         return 0;
 620 }
 621
 622 /*
 623  * Start interface
 624  */
 625 static int esd_usb2_start(struct esd_usb2_net_priv *priv)
 626 {
 627         struct esd_usb2 *dev = priv->usb2;
 628         struct net_device *netdev = priv->netdev;
 629         struct esd_usb2_msg *msg;
 630         int err, i;
 631
 632         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 633         if (!msg) {
 634                 err = -ENOMEM;
 635                 goto out;
 636         }
 637
 638         /*
 639          * Enable all IDs
 640          * The IDADD message takes up to 64 32 bit bitmasks (2048 bits).
 641          * Each bit represents one 11 bit CAN identifier. A set bit
 642          * enables reception of the corresponding CAN identifier. A cleared
 643          * bit disabled this identifier. An additional bitmask value
 644          * following the CAN 2.0A bits is used to enable reception of
 645          * extended CAN frames. Only the LSB of this final mask is checked
 646          * for the complete 29 bit ID range. The IDADD message also allows
 647          * filter configuration for an ID subset. In this case you can add
 648          * the number of the starting bitmask (0..64) to the filter.option
 649          * field followed by only some bitmasks.
 650          */
 651         msg->msg.hdr.cmd = CMD_IDADD;
 652         msg->msg.hdr.len = 2 + ESD_MAX_ID_SEGMENT;
 653         msg->msg.filter.net = priv->index;
 654         msg->msg.filter.option = ESD_ID_ENABLE; /* start with segment 0 */
 655         for (i = 0; i < ESD_MAX_ID_SEGMENT; i++)
 656                 msg->msg.filter.mask[i] = cpu_to_le32(0xffffffff);
 657         /* enable 29bit extended IDs */
 658         msg->msg.filter.mask[ESD_MAX_ID_SEGMENT] = cpu_to_le32(0x00000001);
 659
 660         err = esd_usb2_send_msg(dev, msg);
 661         if (err)
 662                 goto out;
 663
 664         err = esd_usb2_setup_rx_urbs(dev);
 665         if (err)
 666                 goto out;
 667
 668         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 669
 670 out:
 671         if (err == -ENODEV)
 672                 netif_device_detach(netdev);
 673         if (err)
 674                 netdev_err(netdev, "couldn't start device: %d\n", err);
 675
 676         kfree(msg);
 677         return err;
 678 }
 679
 680 static void unlink_all_urbs(struct esd_usb2 *dev)
 681 {
 682         struct esd_usb2_net_priv *priv;
 683         int i, j;
 684
 685         usb_kill_anchored_urbs(&dev->rx_submitted);
 686
 687         for (i = 0; i < MAX_RX_URBS; ++i)
 688                 usb_free_coherent(dev->udev, RX_BUFFER_SIZE,
 689                                   dev->rxbuf[i], dev->rxbuf_dma[i]);
 690
 691         for (i = 0; i < dev->net_count; i++) {
 692                 priv = dev->nets[i];
 693                 if (priv) {
 694                         usb_kill_anchored_urbs(&priv->tx_submitted);
 695                         atomic_set(&priv->active_tx_jobs, 0);
 696
 697                         for (j = 0; j < MAX_TX_URBS; j++)
 698                                 priv->tx_contexts[j].echo_index = MAX_TX_URBS;
 699                 }
 700         }
 701 }
 702
 703 static int esd_usb2_open(struct net_device *netdev)
 704 {
 705         struct esd_usb2_net_priv *priv = netdev_priv(netdev);
 706         int err;
 707
 708         /* common open */
 709         err = open_candev(netdev);
 710         if (err)
 711                 return err;
 712
 713         /* finally start device */
 714         err = esd_usb2_start(priv);
 715         if (err) {
 716                 netdev_warn(netdev, "couldn't start device: %d\n", err);
 717                 close_candev(netdev);
 718                 return err;
 719         }
 720
 721         netif_start_queue(netdev);
 722
 723         return 0;
 724 }
 725
 726 static netdev_tx_t esd_usb2_start_xmit(struct sk_buff *skb,
 727                                       struct net_device *netdev)
 728 {
 729         struct esd_usb2_net_priv *priv = netdev_priv(netdev);
 730         struct esd_usb2 *dev = priv->usb2;
 731         struct esd_tx_urb_context *context = NULL;
 732         struct net_device_stats *stats = &netdev->stats;
 733         struct can_frame *cf = (struct can_frame *)skb->data;
 734         struct esd_usb2_msg *msg;
 735         struct urb *urb;
 736         u8 *buf;
 737         int i, err;
 738         int ret = NETDEV_TX_OK;
 739         size_t size = sizeof(struct esd_usb2_msg);
 740
 741         if (can_dropped_invalid_skb(netdev, skb))
 742                 return NETDEV_TX_OK;
 743
 744         /* create a URB, and a buffer for it, and copy the data to the URB */
 745         urb = usb_alloc_urb(0, GFP_ATOMIC);
 746         if (!urb) {
 747                 stats->tx_dropped++;
 748                 dev_kfree_skb(skb);
 749                 goto nourbmem;
 750         }
 751
 752         buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC,
 753                                  &urb->transfer_dma);
 754         if (!buf) {
 755                 netdev_err(netdev, "No memory left for USB buffer\n");
 756                 stats->tx_dropped++;
 757                 dev_kfree_skb(skb);
 758                 goto nobufmem;
 759         }
 760
 761         msg = (struct esd_usb2_msg *)buf;
 762
 763         msg->msg.hdr.len = 3; /* minimal length */
 764         msg->msg.hdr.cmd = CMD_CAN_TX;
 765         msg->msg.tx.net = priv->index;
 766         msg->msg.tx.dlc = cf->can_dlc;
 767         msg->msg.tx.id = cpu_to_le32(cf->can_id & CAN_ERR_MASK);
 768
 769         if (cf->can_id & CAN_RTR_FLAG)
 770                 msg->msg.tx.dlc |= ESD_RTR;
 771
 772         if (cf->can_id & CAN_EFF_FLAG)
 773                 msg->msg.tx.id |= cpu_to_le32(ESD_EXTID);
 774
 775         for (i = 0; i < cf->can_dlc; i++)
 776                 msg->msg.tx.data[i] = cf->data[i];
 777
 778         msg->msg.hdr.len += (cf->can_dlc + 3) >> 2;
 779
 780         for (i = 0; i < MAX_TX_URBS; i++) {
 781                 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
 782                         context = &priv->tx_contexts[i];
 783                         break;
 784                 }
 785         }
 786
 787         /*
 788          * This may never happen.
 789          */
 790         if (!context) {
 791                 netdev_warn(netdev, "couldn't find free context\n");
 792                 ret = NETDEV_TX_BUSY;
 793                 goto releasebuf;
 794         }
 795
 796         context->priv = priv;
 797         context->echo_index = i;
 798         context->dlc = cf->can_dlc;
 799
 800         /* hnd must not be 0 - MSB is stripped in txdone handling */
 801         msg->msg.tx.hnd = 0x80000000 | i; /* returned in TX done message */
 802
 803         usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf,
 804                           msg->msg.hdr.len << 2,
 805                           esd_usb2_write_bulk_callback, context);
 806
 807         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 808
 809         usb_anchor_urb(urb, &priv->tx_submitted);
 810
 811         can_put_echo_skb(skb, netdev, context->echo_index);
 812
 813         atomic_inc(&priv->active_tx_jobs);
 814
 815         /* Slow down tx path */
 816         if (atomic_read(&priv->active_tx_jobs) >= MAX_TX_URBS)
 817                 netif_stop_queue(netdev);
 818
 819         err = usb_submit_urb(urb, GFP_ATOMIC);
 820         if (err) {
 821                 can_free_echo_skb(netdev, context->echo_index);
 822
 823                 atomic_dec(&priv->active_tx_jobs);
 824                 usb_unanchor_urb(urb);
 825
 826                 stats->tx_dropped++;
 827
 828                 if (err == -ENODEV)
 829                         netif_device_detach(netdev);
 830                 else
 831                         netdev_warn(netdev, "failed tx_urb %d\n", err);
 832
 833                 goto releasebuf;
 834         }
 835
 836         netif_trans_update(netdev);
 837
 838         /*
 839          * Release our reference to this URB, the USB core will eventually free
 840          * it entirely.
 841          */
 842         usb_free_urb(urb);
 843
 844         return NETDEV_TX_OK;
 845
 846 releasebuf:
 847         usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);
 848
 849 nobufmem:
 850         usb_free_urb(urb);
 851
 852 nourbmem:
 853         return ret;
 854 }
 855
 856 static int esd_usb2_close(struct net_device *netdev)
 857 {
 858         struct esd_usb2_net_priv *priv = netdev_priv(netdev);
 859         struct esd_usb2_msg *msg;
 860         int i;
 861
 862         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 863         if (!msg)
 864                 return -ENOMEM;
 865
 866         /* Disable all IDs (see esd_usb2_start()) */
 867         msg->msg.hdr.cmd = CMD_IDADD;
 868         msg->msg.hdr.len = 2 + ESD_MAX_ID_SEGMENT;
 869         msg->msg.filter.net = priv->index;
 870         msg->msg.filter.option = ESD_ID_ENABLE; /* start with segment 0 */
 871         for (i = 0; i <= ESD_MAX_ID_SEGMENT; i++)
 872                 msg->msg.filter.mask[i] = 0;
 873         if (esd_usb2_send_msg(priv->usb2, msg) < 0)
 874                 netdev_err(netdev, "sending idadd message failed\n");
 875
 876         /* set CAN controller to reset mode */
 877         msg->msg.hdr.len = 2;
 878         msg->msg.hdr.cmd = CMD_SETBAUD;
 879         msg->msg.setbaud.net = priv->index;
 880         msg->msg.setbaud.rsvd = 0;
 881         msg->msg.setbaud.baud = cpu_to_le32(ESD_USB2_NO_BAUDRATE);
 882         if (esd_usb2_send_msg(priv->usb2, msg) < 0)
 883                 netdev_err(netdev, "sending setbaud message failed\n");
 884
 885         priv->can.state = CAN_STATE_STOPPED;
 886
 887         netif_stop_queue(netdev);
 888
 889         close_candev(netdev);
 890
 891         kfree(msg);
 892
 893         return 0;
 894 }
 895
 896 static const struct net_device_ops esd_usb2_netdev_ops = {
 897         .ndo_open = esd_usb2_open,
 898         .ndo_stop = esd_usb2_close,
 899         .ndo_start_xmit = esd_usb2_start_xmit,
 900         .ndo_change_mtu = can_change_mtu,
 901 };
 902
 903 static const struct can_bittiming_const esd_usb2_bittiming_const = {
 904         .name = "esd_usb2",
 905         .tseg1_min = ESD_USB2_TSEG1_MIN,
 906         .tseg1_max = ESD_USB2_TSEG1_MAX,
 907         .tseg2_min = ESD_USB2_TSEG2_MIN,
 908         .tseg2_max = ESD_USB2_TSEG2_MAX,
 909         .sjw_max = ESD_USB2_SJW_MAX,
 910         .brp_min = ESD_USB2_BRP_MIN,
 911         .brp_max = ESD_USB2_BRP_MAX,
 912         .brp_inc = ESD_USB2_BRP_INC,
 913 };
 914
 915 static int esd_usb2_set_bittiming(struct net_device *netdev)
 916 {
 917         struct esd_usb2_net_priv *priv = netdev_priv(netdev);
 918         struct can_bittiming *bt = &priv->can.bittiming;
 919         struct esd_usb2_msg *msg;
 920         int err;
 921         u32 canbtr;
 922         int sjw_shift;
 923
 924         canbtr = ESD_USB2_UBR;
 925         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 926                 canbtr |= ESD_USB2_LOM;
 927
 928         canbtr |= (bt->brp - 1) & (ESD_USB2_BRP_MAX - 1);
 929
 930         if (le16_to_cpu(priv->usb2->udev->descriptor.idProduct) ==
 931             USB_CANUSBM_PRODUCT_ID)
 932                 sjw_shift = ESD_USBM_SJW_SHIFT;
 933         else
 934                 sjw_shift = ESD_USB2_SJW_SHIFT;
 935
 936         canbtr |= ((bt->sjw - 1) & (ESD_USB2_SJW_MAX - 1))
 937                 << sjw_shift;
 938         canbtr |= ((bt->prop_seg + bt->phase_seg1 - 1)
 939                    & (ESD_USB2_TSEG1_MAX - 1))
 940                 << ESD_USB2_TSEG1_SHIFT;
 941         canbtr |= ((bt->phase_seg2 - 1) & (ESD_USB2_TSEG2_MAX - 1))
 942                 << ESD_USB2_TSEG2_SHIFT;
 943         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 944                 canbtr |= ESD_USB2_3_SAMPLES;
 945
 946         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 947         if (!msg)
 948                 return -ENOMEM;
 949
 950         msg->msg.hdr.len = 2;
 951         msg->msg.hdr.cmd = CMD_SETBAUD;
 952         msg->msg.setbaud.net = priv->index;
 953         msg->msg.setbaud.rsvd = 0;
 954         msg->msg.setbaud.baud = cpu_to_le32(canbtr);
 955
 956         netdev_info(netdev, "setting BTR=%#x\n", canbtr);
 957
 958         err = esd_usb2_send_msg(priv->usb2, msg);
 959
 960         kfree(msg);
 961         return err;
 962 }
 963
 964 static int esd_usb2_get_berr_counter(const struct net_device *netdev,
 965                                      struct can_berr_counter *bec)
 966 {
 967         struct esd_usb2_net_priv *priv = netdev_priv(netdev);
 968
 969         bec->txerr = priv->bec.txerr;
 970         bec->rxerr = priv->bec.rxerr;
 971
 972         return 0;
 973 }
 974
 975 static int esd_usb2_set_mode(struct net_device *netdev, enum can_mode mode)
 976 {
 977         switch (mode) {
 978         case CAN_MODE_START:
 979                 netif_wake_queue(netdev);
 980                 break;
 981
 982         default:
 983                 return -EOPNOTSUPP;
 984         }
 985
 986         return 0;
 987 }
 988
 989 static int esd_usb2_probe_one_net(struct usb_interface *intf, int index)
 990 {
 991         struct esd_usb2 *dev = usb_get_intfdata(intf);
 992         struct net_device *netdev;
 993         struct esd_usb2_net_priv *priv;
 994         int err = 0;
 995         int i;
 996
 997         netdev = alloc_candev(sizeof(*priv), MAX_TX_URBS);
 998         if (!netdev) {
 999                 dev_err(&intf->dev, "couldn't alloc candev\n");
1000                 err = -ENOMEM;
1001                 goto done;
1002         }
1003
1004         priv = netdev_priv(netdev);
1005
1006         init_usb_anchor(&priv->tx_submitted);
1007         atomic_set(&priv->active_tx_jobs, 0);
1008
1009         for (i = 0; i < MAX_TX_URBS; i++)
1010                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
1011
1012         priv->usb2 = dev;
1013         priv->netdev = netdev;
1014         priv->index = index;
1015
1016         priv->can.state = CAN_STATE_STOPPED;
1017         priv->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1018
1019         if (le16_to_cpu(dev->udev->descriptor.idProduct) ==
1020             USB_CANUSBM_PRODUCT_ID)
1021                 priv->can.clock.freq = ESD_USBM_CAN_CLOCK;
1022         else {
1023                 priv->can.clock.freq = ESD_USB2_CAN_CLOCK;
1024                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1025         }
1026
1027         priv->can.bittiming_const = &esd_usb2_bittiming_const;
1028         priv->can.do_set_bittiming = esd_usb2_set_bittiming;
1029         priv->can.do_set_mode = esd_usb2_set_mode;
1030         priv->can.do_get_berr_counter = esd_usb2_get_berr_counter;
1031
1032         netdev->flags |= IFF_ECHO; /* we support local echo */
1033
1034         netdev->netdev_ops = &esd_usb2_netdev_ops;
1035
1036         SET_NETDEV_DEV(netdev, &intf->dev);
1037         netdev->dev_id = index;
1038
1039         err = register_candev(netdev);
1040         if (err) {
1041                 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
1042                 free_candev(netdev);
1043                 err = -ENOMEM;
1044                 goto done;
1045         }
1046
1047         dev->nets[index] = priv;
1048         netdev_info(netdev, "device %s registered\n", netdev->name);
1049
1050 done:
1051         return err;
1052 }
1053
1054 /*
1055  * probe function for new USB2 devices
1056  *
1057  * check version information and number of available
1058  * CAN interfaces
1059  */
1060 static int esd_usb2_probe(struct usb_interface *intf,
1061                          const struct usb_device_id *id)
1062 {
1063         struct esd_usb2 *dev;
1064         struct esd_usb2_msg *msg;
1065         int i, err;
1066
1067         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1068         if (!dev) {
1069                 err = -ENOMEM;
1070                 goto done;
1071         }
1072
1073         dev->udev = interface_to_usbdev(intf);
1074
1075         init_usb_anchor(&dev->rx_submitted);
1076
1077         usb_set_intfdata(intf, dev);
1078
1079         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1080         if (!msg) {
1081                 err = -ENOMEM;
1082                 goto free_msg;
1083         }
1084
1085         /* query number of CAN interfaces (nets) */
1086         msg->msg.hdr.cmd = CMD_VERSION;
1087         msg->msg.hdr.len = 2;
1088         msg->msg.version.rsvd = 0;
1089         msg->msg.version.flags = 0;
1090         msg->msg.version.drv_version = 0;
1091
1092         err = esd_usb2_send_msg(dev, msg);
1093         if (err < 0) {
1094                 dev_err(&intf->dev, "sending version message failed\n");
1095                 goto free_msg;
1096         }
1097
1098         err = esd_usb2_wait_msg(dev, msg);
1099         if (err < 0) {
1100                 dev_err(&intf->dev, "no version message answer\n");
1101                 goto free_msg;
1102         }
1103
1104         dev->net_count = (int)msg->msg.version_reply.nets;
1105         dev->version = le32_to_cpu(msg->msg.version_reply.version);
1106
1107         if (device_create_file(&intf->dev, &dev_attr_firmware))
1108                 dev_err(&intf->dev,
1109                         "Couldn't create device file for firmware\n");
1110
1111         if (device_create_file(&intf->dev, &dev_attr_hardware))
1112                 dev_err(&intf->dev,
1113                         "Couldn't create device file for hardware\n");
1114
1115         if (device_create_file(&intf->dev, &dev_attr_nets))
1116                 dev_err(&intf->dev,
1117                         "Couldn't create device file for nets\n");
1118
1119         /* do per device probing */
1120         for (i = 0; i < dev->net_count; i++)
1121                 esd_usb2_probe_one_net(intf, i);
1122
1123 free_msg:
1124         kfree(msg);
1125         if (err)
1126                 kfree(dev);
1127 done:
1128         return err;
1129 }
1130
1131 /*
1132  * called by the usb core when the device is removed from the system
1133  */
1134 static void esd_usb2_disconnect(struct usb_interface *intf)
1135 {
1136         struct esd_usb2 *dev = usb_get_intfdata(intf);
1137         struct net_device *netdev;
1138         int i;
1139
1140         device_remove_file(&intf->dev, &dev_attr_firmware);
1141         device_remove_file(&intf->dev, &dev_attr_hardware);
1142         device_remove_file(&intf->dev, &dev_attr_nets);
1143
1144         usb_set_intfdata(intf, NULL);
1145
1146         if (dev) {
1147                 for (i = 0; i < dev->net_count; i++) {
1148                         if (dev->nets[i]) {
1149                                 netdev = dev->nets[i]->netdev;
1150                                 unregister_netdev(netdev);
1151                                 free_candev(netdev);
1152                         }
1153                 }
1154                 unlink_all_urbs(dev);
1155                 kfree(dev);
1156         }
1157 }
1158
1159 /* usb specific object needed to register this driver with the usb subsystem */
1160 static struct usb_driver esd_usb2_driver = {
1161         .name = "esd_usb2",
1162         .probe = esd_usb2_probe,
1163         .disconnect = esd_usb2_disconnect,
1164         .id_table = esd_usb2_table,
1165 };
1166
1167 module_usb_driver(esd_usb2_driver);