Pileus Git - ~andy/linux/blob - drivers/net/can/usb/kvaser_usb.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License as
   4  * published by the Free Software Foundation version 2.
   5  *
   6  * Parts of this driver are based on the following:
   7  *  - Kvaser linux leaf driver (version 4.78)
   8  *  - CAN driver for esd CAN-USB/2
   9  *
  10  * Copyright (C) 2002-2006 KVASER AB, Sweden. All rights reserved.
  11  * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
  12  * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
  13  */
  14
  15 #include <linux/init.h>
  16 #include <linux/completion.h>
  17 #include <linux/module.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/usb.h>
  20
  21 #include <linux/can.h>
  22 #include <linux/can/dev.h>
  23 #include <linux/can/error.h>
  24
  25 #define MAX_TX_URBS                     16
  26 #define MAX_RX_URBS                     4
  27 #define START_TIMEOUT                   1000 /* msecs */
  28 #define STOP_TIMEOUT                    1000 /* msecs */
  29 #define USB_SEND_TIMEOUT                1000 /* msecs */
  30 #define USB_RECV_TIMEOUT                1000 /* msecs */
  31 #define RX_BUFFER_SIZE                  3072
  32 #define CAN_USB_CLOCK                   8000000
  33 #define MAX_NET_DEVICES                 3
  34
  35 /* Kvaser USB devices */
  36 #define KVASER_VENDOR_ID                0x0bfd
  37 #define USB_LEAF_DEVEL_PRODUCT_ID       10
  38 #define USB_LEAF_LITE_PRODUCT_ID        11
  39 #define USB_LEAF_PRO_PRODUCT_ID         12
  40 #define USB_LEAF_SPRO_PRODUCT_ID        14
  41 #define USB_LEAF_PRO_LS_PRODUCT_ID      15
  42 #define USB_LEAF_PRO_SWC_PRODUCT_ID     16
  43 #define USB_LEAF_PRO_LIN_PRODUCT_ID     17
  44 #define USB_LEAF_SPRO_LS_PRODUCT_ID     18
  45 #define USB_LEAF_SPRO_SWC_PRODUCT_ID    19
  46 #define USB_MEMO2_DEVEL_PRODUCT_ID      22
  47 #define USB_MEMO2_HSHS_PRODUCT_ID       23
  48 #define USB_UPRO_HSHS_PRODUCT_ID        24
  49 #define USB_LEAF_LITE_GI_PRODUCT_ID     25
  50 #define USB_LEAF_PRO_OBDII_PRODUCT_ID   26
  51 #define USB_MEMO2_HSLS_PRODUCT_ID       27
  52 #define USB_LEAF_LITE_CH_PRODUCT_ID     28
  53 #define USB_BLACKBIRD_SPRO_PRODUCT_ID   29
  54 #define USB_OEM_MERCURY_PRODUCT_ID      34
  55 #define USB_OEM_LEAF_PRODUCT_ID         35
  56 #define USB_CAN_R_PRODUCT_ID            39
  57
  58 /* USB devices features */
  59 #define KVASER_HAS_SILENT_MODE          BIT(0)
  60 #define KVASER_HAS_TXRX_ERRORS          BIT(1)
  61
  62 /* Message header size */
  63 #define MSG_HEADER_LEN                  2
  64
  65 /* Can message flags */
  66 #define MSG_FLAG_ERROR_FRAME            BIT(0)
  67 #define MSG_FLAG_OVERRUN                BIT(1)
  68 #define MSG_FLAG_NERR                   BIT(2)
  69 #define MSG_FLAG_WAKEUP                 BIT(3)
  70 #define MSG_FLAG_REMOTE_FRAME           BIT(4)
  71 #define MSG_FLAG_RESERVED               BIT(5)
  72 #define MSG_FLAG_TX_ACK                 BIT(6)
  73 #define MSG_FLAG_TX_REQUEST             BIT(7)
  74
  75 /* Can states */
  76 #define M16C_STATE_BUS_RESET            BIT(0)
  77 #define M16C_STATE_BUS_ERROR            BIT(4)
  78 #define M16C_STATE_BUS_PASSIVE          BIT(5)
  79 #define M16C_STATE_BUS_OFF              BIT(6)
  80
  81 /* Can msg ids */
  82 #define CMD_RX_STD_MESSAGE              12
  83 #define CMD_TX_STD_MESSAGE              13
  84 #define CMD_RX_EXT_MESSAGE              14
  85 #define CMD_TX_EXT_MESSAGE              15
  86 #define CMD_SET_BUS_PARAMS              16
  87 #define CMD_GET_BUS_PARAMS              17
  88 #define CMD_GET_BUS_PARAMS_REPLY        18
  89 #define CMD_GET_CHIP_STATE              19
  90 #define CMD_CHIP_STATE_EVENT            20
  91 #define CMD_SET_CTRL_MODE               21
  92 #define CMD_GET_CTRL_MODE               22
  93 #define CMD_GET_CTRL_MODE_REPLY         23
  94 #define CMD_RESET_CHIP                  24
  95 #define CMD_RESET_CARD                  25
  96 #define CMD_START_CHIP                  26
  97 #define CMD_START_CHIP_REPLY            27
  98 #define CMD_STOP_CHIP                   28
  99 #define CMD_STOP_CHIP_REPLY             29
 100 #define CMD_GET_CARD_INFO2              32
 101 #define CMD_GET_CARD_INFO               34
 102 #define CMD_GET_CARD_INFO_REPLY         35
 103 #define CMD_GET_SOFTWARE_INFO           38
 104 #define CMD_GET_SOFTWARE_INFO_REPLY     39
 105 #define CMD_ERROR_EVENT                 45
 106 #define CMD_FLUSH_QUEUE                 48
 107 #define CMD_RESET_ERROR_COUNTER         49
 108 #define CMD_TX_ACKNOWLEDGE              50
 109 #define CMD_CAN_ERROR_EVENT             51
 110 #define CMD_USB_THROTTLE                77
 111 #define CMD_LOG_MESSAGE                 106
 112
 113 /* error factors */
 114 #define M16C_EF_ACKE                    BIT(0)
 115 #define M16C_EF_CRCE                    BIT(1)
 116 #define M16C_EF_FORME                   BIT(2)
 117 #define M16C_EF_STFE                    BIT(3)
 118 #define M16C_EF_BITE0                   BIT(4)
 119 #define M16C_EF_BITE1                   BIT(5)
 120 #define M16C_EF_RCVE                    BIT(6)
 121 #define M16C_EF_TRE                     BIT(7)
 122
 123 /* bittiming parameters */
 124 #define KVASER_USB_TSEG1_MIN            1
 125 #define KVASER_USB_TSEG1_MAX            16
 126 #define KVASER_USB_TSEG2_MIN            1
 127 #define KVASER_USB_TSEG2_MAX            8
 128 #define KVASER_USB_SJW_MAX              4
 129 #define KVASER_USB_BRP_MIN              1
 130 #define KVASER_USB_BRP_MAX              64
 131 #define KVASER_USB_BRP_INC              1
 132
 133 /* ctrl modes */
 134 #define KVASER_CTRL_MODE_NORMAL         1
 135 #define KVASER_CTRL_MODE_SILENT         2
 136 #define KVASER_CTRL_MODE_SELFRECEPTION  3
 137 #define KVASER_CTRL_MODE_OFF            4
 138
 139 struct kvaser_msg_simple {
 140         u8 tid;
 141         u8 channel;
 142 } __packed;
 143
 144 struct kvaser_msg_cardinfo {
 145         u8 tid;
 146         u8 nchannels;
 147         __le32 serial_number;
 148         __le32 padding;
 149         __le32 clock_resolution;
 150         __le32 mfgdate;
 151         u8 ean[8];
 152         u8 hw_revision;
 153         u8 usb_hs_mode;
 154         __le16 padding2;
 155 } __packed;
 156
 157 struct kvaser_msg_cardinfo2 {
 158         u8 tid;
 159         u8 channel;
 160         u8 pcb_id[24];
 161         __le32 oem_unlock_code;
 162 } __packed;
 163
 164 struct kvaser_msg_softinfo {
 165         u8 tid;
 166         u8 channel;
 167         __le32 sw_options;
 168         __le32 fw_version;
 169         __le16 max_outstanding_tx;
 170         __le16 padding[9];
 171 } __packed;
 172
 173 struct kvaser_msg_busparams {
 174         u8 tid;
 175         u8 channel;
 176         __le32 bitrate;
 177         u8 tseg1;
 178         u8 tseg2;
 179         u8 sjw;
 180         u8 no_samp;
 181 } __packed;
 182
 183 struct kvaser_msg_tx_can {
 184         u8 channel;
 185         u8 tid;
 186         u8 msg[14];
 187         u8 padding;
 188         u8 flags;
 189 } __packed;
 190
 191 struct kvaser_msg_rx_can {
 192         u8 channel;
 193         u8 flag;
 194         __le16 time[3];
 195         u8 msg[14];
 196 } __packed;
 197
 198 struct kvaser_msg_chip_state_event {
 199         u8 tid;
 200         u8 channel;
 201         __le16 time[3];
 202         u8 tx_errors_count;
 203         u8 rx_errors_count;
 204         u8 status;
 205         u8 padding[3];
 206 } __packed;
 207
 208 struct kvaser_msg_tx_acknowledge {
 209         u8 channel;
 210         u8 tid;
 211         __le16 time[3];
 212         u8 flags;
 213         u8 time_offset;
 214 } __packed;
 215
 216 struct kvaser_msg_error_event {
 217         u8 tid;
 218         u8 flags;
 219         __le16 time[3];
 220         u8 channel;
 221         u8 padding;
 222         u8 tx_errors_count;
 223         u8 rx_errors_count;
 224         u8 status;
 225         u8 error_factor;
 226 } __packed;
 227
 228 struct kvaser_msg_ctrl_mode {
 229         u8 tid;
 230         u8 channel;
 231         u8 ctrl_mode;
 232         u8 padding[3];
 233 } __packed;
 234
 235 struct kvaser_msg_flush_queue {
 236         u8 tid;
 237         u8 channel;
 238         u8 flags;
 239         u8 padding[3];
 240 } __packed;
 241
 242 struct kvaser_msg_log_message {
 243         u8 channel;
 244         u8 flags;
 245         __le16 time[3];
 246         u8 dlc;
 247         u8 time_offset;
 248         __le32 id;
 249         u8 data[8];
 250 } __packed;
 251
 252 struct kvaser_msg {
 253         u8 len;
 254         u8 id;
 255         union   {
 256                 struct kvaser_msg_simple simple;
 257                 struct kvaser_msg_cardinfo cardinfo;
 258                 struct kvaser_msg_cardinfo2 cardinfo2;
 259                 struct kvaser_msg_softinfo softinfo;
 260                 struct kvaser_msg_busparams busparams;
 261                 struct kvaser_msg_tx_can tx_can;
 262                 struct kvaser_msg_rx_can rx_can;
 263                 struct kvaser_msg_chip_state_event chip_state_event;
 264                 struct kvaser_msg_tx_acknowledge tx_acknowledge;
 265                 struct kvaser_msg_error_event error_event;
 266                 struct kvaser_msg_ctrl_mode ctrl_mode;
 267                 struct kvaser_msg_flush_queue flush_queue;
 268                 struct kvaser_msg_log_message log_message;
 269         } u;
 270 } __packed;
 271
 272 struct kvaser_usb_tx_urb_context {
 273         struct kvaser_usb_net_priv *priv;
 274         u32 echo_index;
 275         int dlc;
 276 };
 277
 278 struct kvaser_usb {
 279         struct usb_device *udev;
 280         struct kvaser_usb_net_priv *nets[MAX_NET_DEVICES];
 281
 282         struct usb_endpoint_descriptor *bulk_in, *bulk_out;
 283         struct usb_anchor rx_submitted;
 284
 285         u32 fw_version;
 286         unsigned int nchannels;
 287
 288         bool rxinitdone;
 289         void *rxbuf[MAX_RX_URBS];
 290         dma_addr_t rxbuf_dma[MAX_RX_URBS];
 291 };
 292
 293 struct kvaser_usb_net_priv {
 294         struct can_priv can;
 295
 296         atomic_t active_tx_urbs;
 297         struct usb_anchor tx_submitted;
 298         struct kvaser_usb_tx_urb_context tx_contexts[MAX_TX_URBS];
 299
 300         struct completion start_comp, stop_comp;
 301
 302         struct kvaser_usb *dev;
 303         struct net_device *netdev;
 304         int channel;
 305
 306         struct can_berr_counter bec;
 307 };
 308
 309 static const struct usb_device_id kvaser_usb_table[] = {
 310         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID) },
 311         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID) },
 312         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID),
 313                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 314                                KVASER_HAS_SILENT_MODE },
 315         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID),
 316                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 317                                KVASER_HAS_SILENT_MODE },
 318         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID),
 319                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 320                                KVASER_HAS_SILENT_MODE },
 321         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID),
 322                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 323                                KVASER_HAS_SILENT_MODE },
 324         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID),
 325                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 326                                KVASER_HAS_SILENT_MODE },
 327         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID),
 328                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 329                                KVASER_HAS_SILENT_MODE },
 330         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID),
 331                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 332                                KVASER_HAS_SILENT_MODE },
 333         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID),
 334                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 335                                KVASER_HAS_SILENT_MODE },
 336         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID),
 337                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 338                                KVASER_HAS_SILENT_MODE },
 339         { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID),
 340                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 341         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID) },
 342         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID),
 343                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 344                                KVASER_HAS_SILENT_MODE },
 345         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID),
 346                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 347         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID),
 348                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 349         { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID),
 350                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 351         { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID),
 352                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 353         { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID),
 354                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 355         { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID),
 356                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 357         { }
 358 };
 359 MODULE_DEVICE_TABLE(usb, kvaser_usb_table);
 360
 361 static inline int kvaser_usb_send_msg(const struct kvaser_usb *dev,
 362                                       struct kvaser_msg *msg)
 363 {
 364         int actual_len;
 365
 366         return usb_bulk_msg(dev->udev,
 367                             usb_sndbulkpipe(dev->udev,
 368                                         dev->bulk_out->bEndpointAddress),
 369                             msg, msg->len, &actual_len,
 370                             USB_SEND_TIMEOUT);
 371 }
 372
 373 static int kvaser_usb_wait_msg(const struct kvaser_usb *dev, u8 id,
 374                                struct kvaser_msg *msg)
 375 {
 376         struct kvaser_msg *tmp;
 377         void *buf;
 378         int actual_len;
 379         int err;
 380         int pos = 0;
 381
 382         buf = kzalloc(RX_BUFFER_SIZE, GFP_KERNEL);
 383         if (!buf)
 384                 return -ENOMEM;
 385
 386         err = usb_bulk_msg(dev->udev,
 387                            usb_rcvbulkpipe(dev->udev,
 388                                            dev->bulk_in->bEndpointAddress),
 389                            buf, RX_BUFFER_SIZE, &actual_len,
 390                            USB_RECV_TIMEOUT);
 391         if (err < 0)
 392                 goto end;
 393
 394         while (pos <= actual_len - MSG_HEADER_LEN) {
 395                 tmp = buf + pos;
 396
 397                 if (!tmp->len)
 398                         break;
 399
 400                 if (pos + tmp->len > actual_len) {
 401                         dev_err(dev->udev->dev.parent, "Format error\n");
 402                         break;
 403                 }
 404
 405                 if (tmp->id == id) {
 406                         memcpy(msg, tmp, tmp->len);
 407                         goto end;
 408                 }
 409
 410                 pos += tmp->len;
 411         }
 412
 413         err = -EINVAL;
 414
 415 end:
 416         kfree(buf);
 417
 418         return err;
 419 }
 420
 421 static int kvaser_usb_send_simple_msg(const struct kvaser_usb *dev,
 422                                       u8 msg_id, int channel)
 423 {
 424         struct kvaser_msg *msg;
 425         int rc;
 426
 427         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 428         if (!msg)
 429                 return -ENOMEM;
 430
 431         msg->id = msg_id;
 432         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
 433         msg->u.simple.channel = channel;
 434         msg->u.simple.tid = 0xff;
 435
 436         rc = kvaser_usb_send_msg(dev, msg);
 437
 438         kfree(msg);
 439         return rc;
 440 }
 441
 442 static int kvaser_usb_get_software_info(struct kvaser_usb *dev)
 443 {
 444         struct kvaser_msg msg;
 445         int err;
 446
 447         err = kvaser_usb_send_simple_msg(dev, CMD_GET_SOFTWARE_INFO, 0);
 448         if (err)
 449                 return err;
 450
 451         err = kvaser_usb_wait_msg(dev, CMD_GET_SOFTWARE_INFO_REPLY, &msg);
 452         if (err)
 453                 return err;
 454
 455         dev->fw_version = le32_to_cpu(msg.u.softinfo.fw_version);
 456
 457         return 0;
 458 }
 459
 460 static int kvaser_usb_get_card_info(struct kvaser_usb *dev)
 461 {
 462         struct kvaser_msg msg;
 463         int err;
 464
 465         err = kvaser_usb_send_simple_msg(dev, CMD_GET_CARD_INFO, 0);
 466         if (err)
 467                 return err;
 468
 469         err = kvaser_usb_wait_msg(dev, CMD_GET_CARD_INFO_REPLY, &msg);
 470         if (err)
 471                 return err;
 472
 473         dev->nchannels = msg.u.cardinfo.nchannels;
 474
 475         return 0;
 476 }
 477
 478 static void kvaser_usb_tx_acknowledge(const struct kvaser_usb *dev,
 479                                       const struct kvaser_msg *msg)
 480 {
 481         struct net_device_stats *stats;
 482         struct kvaser_usb_tx_urb_context *context;
 483         struct kvaser_usb_net_priv *priv;
 484         struct sk_buff *skb;
 485         struct can_frame *cf;
 486         u8 channel = msg->u.tx_acknowledge.channel;
 487         u8 tid = msg->u.tx_acknowledge.tid;
 488
 489         if (channel >= dev->nchannels) {
 490                 dev_err(dev->udev->dev.parent,
 491                         "Invalid channel number (%d)\n", channel);
 492                 return;
 493         }
 494
 495         priv = dev->nets[channel];
 496
 497         if (!netif_device_present(priv->netdev))
 498                 return;
 499
 500         stats = &priv->netdev->stats;
 501
 502         context = &priv->tx_contexts[tid % MAX_TX_URBS];
 503
 504         /* Sometimes the state change doesn't come after a bus-off event */
 505         if (priv->can.restart_ms &&
 506             (priv->can.state >= CAN_STATE_BUS_OFF)) {
 507                 skb = alloc_can_err_skb(priv->netdev, &cf);
 508                 if (skb) {
 509                         cf->can_id |= CAN_ERR_RESTARTED;
 510                         netif_rx(skb);
 511
 512                         stats->rx_packets++;
 513                         stats->rx_bytes += cf->can_dlc;
 514                 } else {
 515                         netdev_err(priv->netdev,
 516                                    "No memory left for err_skb\n");
 517                 }
 518
 519                 priv->can.can_stats.restarts++;
 520                 netif_carrier_on(priv->netdev);
 521
 522                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
 523         }
 524
 525         stats->tx_packets++;
 526         stats->tx_bytes += context->dlc;
 527         can_get_echo_skb(priv->netdev, context->echo_index);
 528
 529         context->echo_index = MAX_TX_URBS;
 530         atomic_dec(&priv->active_tx_urbs);
 531
 532         netif_wake_queue(priv->netdev);
 533 }
 534
 535 static void kvaser_usb_simple_msg_callback(struct urb *urb)
 536 {
 537         struct net_device *netdev = urb->context;
 538
 539         kfree(urb->transfer_buffer);
 540
 541         if (urb->status)
 542                 netdev_warn(netdev, "urb status received: %d\n",
 543                             urb->status);
 544 }
 545
 546 static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv *priv,
 547                                        u8 msg_id)
 548 {
 549         struct kvaser_usb *dev = priv->dev;
 550         struct net_device *netdev = priv->netdev;
 551         struct kvaser_msg *msg;
 552         struct urb *urb;
 553         void *buf;
 554         int err;
 555
 556         urb = usb_alloc_urb(0, GFP_ATOMIC);
 557         if (!urb) {
 558                 netdev_err(netdev, "No memory left for URBs\n");
 559                 return -ENOMEM;
 560         }
 561
 562         buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
 563         if (!buf) {
 564                 usb_free_urb(urb);
 565                 return -ENOMEM;
 566         }
 567
 568         msg = (struct kvaser_msg *)buf;
 569         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
 570         msg->id = msg_id;
 571         msg->u.simple.channel = priv->channel;
 572
 573         usb_fill_bulk_urb(urb, dev->udev,
 574                           usb_sndbulkpipe(dev->udev,
 575                                           dev->bulk_out->bEndpointAddress),
 576                           buf, msg->len,
 577                           kvaser_usb_simple_msg_callback, priv);
 578         usb_anchor_urb(urb, &priv->tx_submitted);
 579
 580         err = usb_submit_urb(urb, GFP_ATOMIC);
 581         if (err) {
 582                 netdev_err(netdev, "Error transmitting URB\n");
 583                 usb_unanchor_urb(urb);
 584                 usb_free_urb(urb);
 585                 kfree(buf);
 586                 return err;
 587         }
 588
 589         usb_free_urb(urb);
 590
 591         return 0;
 592 }
 593
 594 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv)
 595 {
 596         int i;
 597
 598         usb_kill_anchored_urbs(&priv->tx_submitted);
 599         atomic_set(&priv->active_tx_urbs, 0);
 600
 601         for (i = 0; i < MAX_TX_URBS; i++)
 602                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
 603 }
 604
 605 static void kvaser_usb_rx_error(const struct kvaser_usb *dev,
 606                                 const struct kvaser_msg *msg)
 607 {
 608         struct can_frame *cf;
 609         struct sk_buff *skb;
 610         struct net_device_stats *stats;
 611         struct kvaser_usb_net_priv *priv;
 612         unsigned int new_state;
 613         u8 channel, status, txerr, rxerr, error_factor;
 614
 615         switch (msg->id) {
 616         case CMD_CAN_ERROR_EVENT:
 617                 channel = msg->u.error_event.channel;
 618                 status =  msg->u.error_event.status;
 619                 txerr = msg->u.error_event.tx_errors_count;
 620                 rxerr = msg->u.error_event.rx_errors_count;
 621                 error_factor = msg->u.error_event.error_factor;
 622                 break;
 623         case CMD_LOG_MESSAGE:
 624                 channel = msg->u.log_message.channel;
 625                 status = msg->u.log_message.data[0];
 626                 txerr = msg->u.log_message.data[2];
 627                 rxerr = msg->u.log_message.data[3];
 628                 error_factor = msg->u.log_message.data[1];
 629                 break;
 630         case CMD_CHIP_STATE_EVENT:
 631                 channel = msg->u.chip_state_event.channel;
 632                 status =  msg->u.chip_state_event.status;
 633                 txerr = msg->u.chip_state_event.tx_errors_count;
 634                 rxerr = msg->u.chip_state_event.rx_errors_count;
 635                 error_factor = 0;
 636                 break;
 637         default:
 638                 dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n",
 639                         msg->id);
 640                 return;
 641         }
 642
 643         if (channel >= dev->nchannels) {
 644                 dev_err(dev->udev->dev.parent,
 645                         "Invalid channel number (%d)\n", channel);
 646                 return;
 647         }
 648
 649         priv = dev->nets[channel];
 650         stats = &priv->netdev->stats;
 651
 652         if (status & M16C_STATE_BUS_RESET) {
 653                 kvaser_usb_unlink_tx_urbs(priv);
 654                 return;
 655         }
 656
 657         skb = alloc_can_err_skb(priv->netdev, &cf);
 658         if (!skb) {
 659                 stats->rx_dropped++;
 660                 return;
 661         }
 662
 663         new_state = priv->can.state;
 664
 665         netdev_dbg(priv->netdev, "Error status: 0x%02x\n", status);
 666
 667         if (status & M16C_STATE_BUS_OFF) {
 668                 cf->can_id |= CAN_ERR_BUSOFF;
 669
 670                 priv->can.can_stats.bus_off++;
 671                 if (!priv->can.restart_ms)
 672                         kvaser_usb_simple_msg_async(priv, CMD_STOP_CHIP);
 673
 674                 netif_carrier_off(priv->netdev);
 675
 676                 new_state = CAN_STATE_BUS_OFF;
 677         } else if (status & M16C_STATE_BUS_PASSIVE) {
 678                 if (priv->can.state != CAN_STATE_ERROR_PASSIVE) {
 679                         cf->can_id |= CAN_ERR_CRTL;
 680
 681                         if (txerr || rxerr)
 682                                 cf->data[1] = (txerr > rxerr)
 683                                                 ? CAN_ERR_CRTL_TX_PASSIVE
 684                                                 : CAN_ERR_CRTL_RX_PASSIVE;
 685                         else
 686                                 cf->data[1] = CAN_ERR_CRTL_TX_PASSIVE |
 687                                               CAN_ERR_CRTL_RX_PASSIVE;
 688
 689                         priv->can.can_stats.error_passive++;
 690                 }
 691
 692                 new_state = CAN_STATE_ERROR_PASSIVE;
 693         }
 694
 695         if (status == M16C_STATE_BUS_ERROR) {
 696                 if ((priv->can.state < CAN_STATE_ERROR_WARNING) &&
 697                     ((txerr >= 96) || (rxerr >= 96))) {
 698                         cf->can_id |= CAN_ERR_CRTL;
 699                         cf->data[1] = (txerr > rxerr)
 700                                         ? CAN_ERR_CRTL_TX_WARNING
 701                                         : CAN_ERR_CRTL_RX_WARNING;
 702
 703                         priv->can.can_stats.error_warning++;
 704                         new_state = CAN_STATE_ERROR_WARNING;
 705                 } else if (priv->can.state > CAN_STATE_ERROR_ACTIVE) {
 706                         cf->can_id |= CAN_ERR_PROT;
 707                         cf->data[2] = CAN_ERR_PROT_ACTIVE;
 708
 709                         new_state = CAN_STATE_ERROR_ACTIVE;
 710                 }
 711         }
 712
 713         if (!status) {
 714                 cf->can_id |= CAN_ERR_PROT;
 715                 cf->data[2] = CAN_ERR_PROT_ACTIVE;
 716
 717                 new_state = CAN_STATE_ERROR_ACTIVE;
 718         }
 719
 720         if (priv->can.restart_ms &&
 721             (priv->can.state >= CAN_STATE_BUS_OFF) &&
 722             (new_state < CAN_STATE_BUS_OFF)) {
 723                 cf->can_id |= CAN_ERR_RESTARTED;
 724                 netif_carrier_on(priv->netdev);
 725
 726                 priv->can.can_stats.restarts++;
 727         }
 728
 729         if (error_factor) {
 730                 priv->can.can_stats.bus_error++;
 731                 stats->rx_errors++;
 732
 733                 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
 734
 735                 if (error_factor & M16C_EF_ACKE)
 736                         cf->data[3] |= (CAN_ERR_PROT_LOC_ACK);
 737                 if (error_factor & M16C_EF_CRCE)
 738                         cf->data[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ |
 739                                         CAN_ERR_PROT_LOC_CRC_DEL);
 740                 if (error_factor & M16C_EF_FORME)
 741                         cf->data[2] |= CAN_ERR_PROT_FORM;
 742                 if (error_factor & M16C_EF_STFE)
 743                         cf->data[2] |= CAN_ERR_PROT_STUFF;
 744                 if (error_factor & M16C_EF_BITE0)
 745                         cf->data[2] |= CAN_ERR_PROT_BIT0;
 746                 if (error_factor & M16C_EF_BITE1)
 747                         cf->data[2] |= CAN_ERR_PROT_BIT1;
 748                 if (error_factor & M16C_EF_TRE)
 749                         cf->data[2] |= CAN_ERR_PROT_TX;
 750         }
 751
 752         cf->data[6] = txerr;
 753         cf->data[7] = rxerr;
 754
 755         priv->bec.txerr = txerr;
 756         priv->bec.rxerr = rxerr;
 757
 758         priv->can.state = new_state;
 759
 760         netif_rx(skb);
 761
 762         stats->rx_packets++;
 763         stats->rx_bytes += cf->can_dlc;
 764 }
 765
 766 static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv *priv,
 767                                   const struct kvaser_msg *msg)
 768 {
 769         struct can_frame *cf;
 770         struct sk_buff *skb;
 771         struct net_device_stats *stats = &priv->netdev->stats;
 772
 773         if (msg->u.rx_can.flag & (MSG_FLAG_ERROR_FRAME |
 774                                          MSG_FLAG_NERR)) {
 775                 netdev_err(priv->netdev, "Unknow error (flags: 0x%02x)\n",
 776                            msg->u.rx_can.flag);
 777
 778                 stats->rx_errors++;
 779                 return;
 780         }
 781
 782         if (msg->u.rx_can.flag & MSG_FLAG_OVERRUN) {
 783                 skb = alloc_can_err_skb(priv->netdev, &cf);
 784                 if (!skb) {
 785                         stats->rx_dropped++;
 786                         return;
 787                 }
 788
 789                 cf->can_id |= CAN_ERR_CRTL;
 790                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 791
 792                 stats->rx_over_errors++;
 793                 stats->rx_errors++;
 794
 795                 netif_rx(skb);
 796
 797                 stats->rx_packets++;
 798                 stats->rx_bytes += cf->can_dlc;
 799         }
 800 }
 801
 802 static void kvaser_usb_rx_can_msg(const struct kvaser_usb *dev,
 803                                   const struct kvaser_msg *msg)
 804 {
 805         struct kvaser_usb_net_priv *priv;
 806         struct can_frame *cf;
 807         struct sk_buff *skb;
 808         struct net_device_stats *stats;
 809         u8 channel = msg->u.rx_can.channel;
 810
 811         if (channel >= dev->nchannels) {
 812                 dev_err(dev->udev->dev.parent,
 813                         "Invalid channel number (%d)\n", channel);
 814                 return;
 815         }
 816
 817         priv = dev->nets[channel];
 818         stats = &priv->netdev->stats;
 819
 820         if (msg->u.rx_can.flag & (MSG_FLAG_ERROR_FRAME | MSG_FLAG_NERR |
 821                                   MSG_FLAG_OVERRUN)) {
 822                 kvaser_usb_rx_can_err(priv, msg);
 823                 return;
 824         } else if (msg->u.rx_can.flag & ~MSG_FLAG_REMOTE_FRAME) {
 825                 netdev_warn(priv->netdev,
 826                             "Unhandled frame (flags: 0x%02x)",
 827                             msg->u.rx_can.flag);
 828                 return;
 829         }
 830
 831         skb = alloc_can_skb(priv->netdev, &cf);
 832         if (!skb) {
 833                 stats->tx_dropped++;
 834                 return;
 835         }
 836
 837         cf->can_id = ((msg->u.rx_can.msg[0] & 0x1f) << 6) |
 838                      (msg->u.rx_can.msg[1] & 0x3f);
 839         cf->can_dlc = get_can_dlc(msg->u.rx_can.msg[5]);
 840
 841         if (msg->id == CMD_RX_EXT_MESSAGE) {
 842                 cf->can_id <<= 18;
 843                 cf->can_id |= ((msg->u.rx_can.msg[2] & 0x0f) << 14) |
 844                               ((msg->u.rx_can.msg[3] & 0xff) << 6) |
 845                               (msg->u.rx_can.msg[4] & 0x3f);
 846                 cf->can_id |= CAN_EFF_FLAG;
 847         }
 848
 849         if (msg->u.rx_can.flag & MSG_FLAG_REMOTE_FRAME)
 850                 cf->can_id |= CAN_RTR_FLAG;
 851         else
 852                 memcpy(cf->data, &msg->u.rx_can.msg[6], cf->can_dlc);
 853
 854         netif_rx(skb);
 855
 856         stats->rx_packets++;
 857         stats->rx_bytes += cf->can_dlc;
 858 }
 859
 860 static void kvaser_usb_start_chip_reply(const struct kvaser_usb *dev,
 861                                         const struct kvaser_msg *msg)
 862 {
 863         struct kvaser_usb_net_priv *priv;
 864         u8 channel = msg->u.simple.channel;
 865
 866         if (channel >= dev->nchannels) {
 867                 dev_err(dev->udev->dev.parent,
 868                         "Invalid channel number (%d)\n", channel);
 869                 return;
 870         }
 871
 872         priv = dev->nets[channel];
 873
 874         if (completion_done(&priv->start_comp) &&
 875             netif_queue_stopped(priv->netdev)) {
 876                 netif_wake_queue(priv->netdev);
 877         } else {
 878                 netif_start_queue(priv->netdev);
 879                 complete(&priv->start_comp);
 880         }
 881 }
 882
 883 static void kvaser_usb_stop_chip_reply(const struct kvaser_usb *dev,
 884                                        const struct kvaser_msg *msg)
 885 {
 886         struct kvaser_usb_net_priv *priv;
 887         u8 channel = msg->u.simple.channel;
 888
 889         if (channel >= dev->nchannels) {
 890                 dev_err(dev->udev->dev.parent,
 891                         "Invalid channel number (%d)\n", channel);
 892                 return;
 893         }
 894
 895         priv = dev->nets[channel];
 896
 897         complete(&priv->stop_comp);
 898 }
 899
 900 static void kvaser_usb_handle_message(const struct kvaser_usb *dev,
 901                                       const struct kvaser_msg *msg)
 902 {
 903         switch (msg->id) {
 904         case CMD_START_CHIP_REPLY:
 905                 kvaser_usb_start_chip_reply(dev, msg);
 906                 break;
 907
 908         case CMD_STOP_CHIP_REPLY:
 909                 kvaser_usb_stop_chip_reply(dev, msg);
 910                 break;
 911
 912         case CMD_RX_STD_MESSAGE:
 913         case CMD_RX_EXT_MESSAGE:
 914                 kvaser_usb_rx_can_msg(dev, msg);
 915                 break;
 916
 917         case CMD_CHIP_STATE_EVENT:
 918         case CMD_CAN_ERROR_EVENT:
 919                 kvaser_usb_rx_error(dev, msg);
 920                 break;
 921
 922         case CMD_LOG_MESSAGE:
 923                 if (msg->u.log_message.flags & MSG_FLAG_ERROR_FRAME)
 924                         kvaser_usb_rx_error(dev, msg);
 925                 break;
 926
 927         case CMD_TX_ACKNOWLEDGE:
 928                 kvaser_usb_tx_acknowledge(dev, msg);
 929                 break;
 930
 931         default:
 932                 dev_warn(dev->udev->dev.parent,
 933                          "Unhandled message (%d)\n", msg->id);
 934                 break;
 935         }
 936 }
 937
 938 static void kvaser_usb_read_bulk_callback(struct urb *urb)
 939 {
 940         struct kvaser_usb *dev = urb->context;
 941         struct kvaser_msg *msg;
 942         int pos = 0;
 943         int err, i;
 944
 945         switch (urb->status) {
 946         case 0:
 947                 break;
 948         case -ENOENT:
 949         case -ESHUTDOWN:
 950                 return;
 951         default:
 952                 dev_info(dev->udev->dev.parent, "Rx URB aborted (%d)\n",
 953                          urb->status);
 954                 goto resubmit_urb;
 955         }
 956
 957         while (pos <= urb->actual_length - MSG_HEADER_LEN) {
 958                 msg = urb->transfer_buffer + pos;
 959
 960                 if (!msg->len)
 961                         break;
 962
 963                 if (pos + msg->len > urb->actual_length) {
 964                         dev_err(dev->udev->dev.parent, "Format error\n");
 965                         break;
 966                 }
 967
 968                 kvaser_usb_handle_message(dev, msg);
 969
 970                 pos += msg->len;
 971         }
 972
 973 resubmit_urb:
 974         usb_fill_bulk_urb(urb, dev->udev,
 975                           usb_rcvbulkpipe(dev->udev,
 976                                           dev->bulk_in->bEndpointAddress),
 977                           urb->transfer_buffer, RX_BUFFER_SIZE,
 978                           kvaser_usb_read_bulk_callback, dev);
 979
 980         err = usb_submit_urb(urb, GFP_ATOMIC);
 981         if (err == -ENODEV) {
 982                 for (i = 0; i < dev->nchannels; i++) {
 983                         if (!dev->nets[i])
 984                                 continue;
 985
 986                         netif_device_detach(dev->nets[i]->netdev);
 987                 }
 988         } else if (err) {
 989                 dev_err(dev->udev->dev.parent,
 990                         "Failed resubmitting read bulk urb: %d\n", err);
 991         }
 992
 993         return;
 994 }
 995
 996 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev)
 997 {
 998         int i, err = 0;
 999
1000         if (dev->rxinitdone)
1001                 return 0;
1002
1003         for (i = 0; i < MAX_RX_URBS; i++) {
1004                 struct urb *urb = NULL;
1005                 u8 *buf = NULL;
1006                 dma_addr_t buf_dma;
1007
1008                 urb = usb_alloc_urb(0, GFP_KERNEL);
1009                 if (!urb) {
1010                         dev_warn(dev->udev->dev.parent,
1011                                  "No memory left for URBs\n");
1012                         err = -ENOMEM;
1013                         break;
1014                 }
1015
1016                 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE,
1017                                          GFP_KERNEL, &buf_dma);
1018                 if (!buf) {
1019                         dev_warn(dev->udev->dev.parent,
1020                                  "No memory left for USB buffer\n");
1021                         usb_free_urb(urb);
1022                         err = -ENOMEM;
1023                         break;
1024                 }
1025
1026                 usb_fill_bulk_urb(urb, dev->udev,
1027                                   usb_rcvbulkpipe(dev->udev,
1028                                           dev->bulk_in->bEndpointAddress),
1029                                   buf, RX_BUFFER_SIZE,
1030                                   kvaser_usb_read_bulk_callback,
1031                                   dev);
1032                 urb->transfer_dma = buf_dma;
1033                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1034                 usb_anchor_urb(urb, &dev->rx_submitted);
1035
1036                 err = usb_submit_urb(urb, GFP_KERNEL);
1037                 if (err) {
1038                         usb_unanchor_urb(urb);
1039                         usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
1040                                           buf_dma);
1041                         usb_free_urb(urb);
1042                         break;
1043                 }
1044
1045                 dev->rxbuf[i] = buf;
1046                 dev->rxbuf_dma[i] = buf_dma;
1047
1048                 usb_free_urb(urb);
1049         }
1050
1051         if (i == 0) {
1052                 dev_warn(dev->udev->dev.parent,
1053                          "Cannot setup read URBs, error %d\n", err);
1054                 return err;
1055         } else if (i < MAX_RX_URBS) {
1056                 dev_warn(dev->udev->dev.parent,
1057                          "RX performances may be slow\n");
1058         }
1059
1060         dev->rxinitdone = true;
1061
1062         return 0;
1063 }
1064
1065 static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1066 {
1067         struct kvaser_msg *msg;
1068         int rc;
1069
1070         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1071         if (!msg)
1072                 return -ENOMEM;
1073
1074         msg->id = CMD_SET_CTRL_MODE;
1075         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_ctrl_mode);
1076         msg->u.ctrl_mode.tid = 0xff;
1077         msg->u.ctrl_mode.channel = priv->channel;
1078
1079         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1080                 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1081         else
1082                 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1083
1084         rc = kvaser_usb_send_msg(priv->dev, msg);
1085
1086         kfree(msg);
1087         return rc;
1088 }
1089
1090 static int kvaser_usb_start_chip(struct kvaser_usb_net_priv *priv)
1091 {
1092         int err;
1093
1094         init_completion(&priv->start_comp);
1095
1096         err = kvaser_usb_send_simple_msg(priv->dev, CMD_START_CHIP,
1097                                          priv->channel);
1098         if (err)
1099                 return err;
1100
1101         if (!wait_for_completion_timeout(&priv->start_comp,
1102                                          msecs_to_jiffies(START_TIMEOUT)))
1103                 return -ETIMEDOUT;
1104
1105         return 0;
1106 }
1107
1108 static int kvaser_usb_open(struct net_device *netdev)
1109 {
1110         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1111         struct kvaser_usb *dev = priv->dev;
1112         int err;
1113
1114         err = open_candev(netdev);
1115         if (err)
1116                 return err;
1117
1118         err = kvaser_usb_setup_rx_urbs(dev);
1119         if (err)
1120                 goto error;
1121
1122         err = kvaser_usb_set_opt_mode(priv);
1123         if (err)
1124                 goto error;
1125
1126         err = kvaser_usb_start_chip(priv);
1127         if (err) {
1128                 netdev_warn(netdev, "Cannot start device, error %d\n", err);
1129                 goto error;
1130         }
1131
1132         priv->can.state = CAN_STATE_ERROR_ACTIVE;
1133
1134         return 0;
1135
1136 error:
1137         close_candev(netdev);
1138         return err;
1139 }
1140
1141 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev)
1142 {
1143         int i;
1144
1145         usb_kill_anchored_urbs(&dev->rx_submitted);
1146
1147         for (i = 0; i < MAX_RX_URBS; i++)
1148                 usb_free_coherent(dev->udev, RX_BUFFER_SIZE,
1149                                   dev->rxbuf[i],
1150                                   dev->rxbuf_dma[i]);
1151
1152         for (i = 0; i < MAX_NET_DEVICES; i++) {
1153                 struct kvaser_usb_net_priv *priv = dev->nets[i];
1154
1155                 if (priv)
1156                         kvaser_usb_unlink_tx_urbs(priv);
1157         }
1158 }
1159
1160 static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv *priv)
1161 {
1162         int err;
1163
1164         init_completion(&priv->stop_comp);
1165
1166         err = kvaser_usb_send_simple_msg(priv->dev, CMD_STOP_CHIP,
1167                                          priv->channel);
1168         if (err)
1169                 return err;
1170
1171         if (!wait_for_completion_timeout(&priv->stop_comp,
1172                                          msecs_to_jiffies(STOP_TIMEOUT)))
1173                 return -ETIMEDOUT;
1174
1175         return 0;
1176 }
1177
1178 static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv *priv)
1179 {
1180         struct kvaser_msg *msg;
1181         int rc;
1182
1183         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1184         if (!msg)
1185                 return -ENOMEM;
1186
1187         msg->id = CMD_FLUSH_QUEUE;
1188         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_flush_queue);
1189         msg->u.flush_queue.channel = priv->channel;
1190         msg->u.flush_queue.flags = 0x00;
1191
1192         rc = kvaser_usb_send_msg(priv->dev, msg);
1193
1194         kfree(msg);
1195         return rc;
1196 }
1197
1198 static int kvaser_usb_close(struct net_device *netdev)
1199 {
1200         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1201         struct kvaser_usb *dev = priv->dev;
1202         int err;
1203
1204         netif_stop_queue(netdev);
1205
1206         err = kvaser_usb_flush_queue(priv);
1207         if (err)
1208                 netdev_warn(netdev, "Cannot flush queue, error %d\n", err);
1209
1210         if (kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, priv->channel))
1211                 netdev_warn(netdev, "Cannot reset card, error %d\n", err);
1212
1213         err = kvaser_usb_stop_chip(priv);
1214         if (err)
1215                 netdev_warn(netdev, "Cannot stop device, error %d\n", err);
1216
1217         priv->can.state = CAN_STATE_STOPPED;
1218         close_candev(priv->netdev);
1219
1220         return 0;
1221 }
1222
1223 static void kvaser_usb_write_bulk_callback(struct urb *urb)
1224 {
1225         struct kvaser_usb_tx_urb_context *context = urb->context;
1226         struct kvaser_usb_net_priv *priv;
1227         struct net_device *netdev;
1228
1229         if (WARN_ON(!context))
1230                 return;
1231
1232         priv = context->priv;
1233         netdev = priv->netdev;
1234
1235         kfree(urb->transfer_buffer);
1236
1237         if (!netif_device_present(netdev))
1238                 return;
1239
1240         if (urb->status)
1241                 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
1242 }
1243
1244 static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb,
1245                                          struct net_device *netdev)
1246 {
1247         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1248         struct kvaser_usb *dev = priv->dev;
1249         struct net_device_stats *stats = &netdev->stats;
1250         struct can_frame *cf = (struct can_frame *)skb->data;
1251         struct kvaser_usb_tx_urb_context *context = NULL;
1252         struct urb *urb;
1253         void *buf;
1254         struct kvaser_msg *msg;
1255         int i, err;
1256         int ret = NETDEV_TX_OK;
1257
1258         if (can_dropped_invalid_skb(netdev, skb))
1259                 return NETDEV_TX_OK;
1260
1261         urb = usb_alloc_urb(0, GFP_ATOMIC);
1262         if (!urb) {
1263                 netdev_err(netdev, "No memory left for URBs\n");
1264                 stats->tx_dropped++;
1265                 goto nourbmem;
1266         }
1267
1268         buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
1269         if (!buf) {
1270                 stats->tx_dropped++;
1271                 goto nobufmem;
1272         }
1273
1274         msg = buf;
1275         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_tx_can);
1276         msg->u.tx_can.flags = 0;
1277         msg->u.tx_can.channel = priv->channel;
1278
1279         if (cf->can_id & CAN_EFF_FLAG) {
1280                 msg->id = CMD_TX_EXT_MESSAGE;
1281                 msg->u.tx_can.msg[0] = (cf->can_id >> 24) & 0x1f;
1282                 msg->u.tx_can.msg[1] = (cf->can_id >> 18) & 0x3f;
1283                 msg->u.tx_can.msg[2] = (cf->can_id >> 14) & 0x0f;
1284                 msg->u.tx_can.msg[3] = (cf->can_id >> 6) & 0xff;
1285                 msg->u.tx_can.msg[4] = cf->can_id & 0x3f;
1286         } else {
1287                 msg->id = CMD_TX_STD_MESSAGE;
1288                 msg->u.tx_can.msg[0] = (cf->can_id >> 6) & 0x1f;
1289                 msg->u.tx_can.msg[1] = cf->can_id & 0x3f;
1290         }
1291
1292         msg->u.tx_can.msg[5] = cf->can_dlc;
1293         memcpy(&msg->u.tx_can.msg[6], cf->data, cf->can_dlc);
1294
1295         if (cf->can_id & CAN_RTR_FLAG)
1296                 msg->u.tx_can.flags |= MSG_FLAG_REMOTE_FRAME;
1297
1298         for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++) {
1299                 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
1300                         context = &priv->tx_contexts[i];
1301                         break;
1302                 }
1303         }
1304
1305         if (!context) {
1306                 netdev_warn(netdev, "cannot find free context\n");
1307                 ret =  NETDEV_TX_BUSY;
1308                 goto releasebuf;
1309         }
1310
1311         context->priv = priv;
1312         context->echo_index = i;
1313         context->dlc = cf->can_dlc;
1314
1315         msg->u.tx_can.tid = context->echo_index;
1316
1317         usb_fill_bulk_urb(urb, dev->udev,
1318                           usb_sndbulkpipe(dev->udev,
1319                                           dev->bulk_out->bEndpointAddress),
1320                           buf, msg->len,
1321                           kvaser_usb_write_bulk_callback, context);
1322         usb_anchor_urb(urb, &priv->tx_submitted);
1323
1324         can_put_echo_skb(skb, netdev, context->echo_index);
1325
1326         atomic_inc(&priv->active_tx_urbs);
1327
1328         if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
1329                 netif_stop_queue(netdev);
1330
1331         err = usb_submit_urb(urb, GFP_ATOMIC);
1332         if (unlikely(err)) {
1333                 can_free_echo_skb(netdev, context->echo_index);
1334
1335                 skb = NULL; /* set to NULL to avoid double free in
1336                              * dev_kfree_skb(skb) */
1337
1338                 atomic_dec(&priv->active_tx_urbs);
1339                 usb_unanchor_urb(urb);
1340
1341                 stats->tx_dropped++;
1342
1343                 if (err == -ENODEV)
1344                         netif_device_detach(netdev);
1345                 else
1346                         netdev_warn(netdev, "Failed tx_urb %d\n", err);
1347
1348                 goto releasebuf;
1349         }
1350
1351         usb_free_urb(urb);
1352
1353         return NETDEV_TX_OK;
1354
1355 releasebuf:
1356         kfree(buf);
1357 nobufmem:
1358         usb_free_urb(urb);
1359 nourbmem:
1360         dev_kfree_skb(skb);
1361         return ret;
1362 }
1363
1364 static const struct net_device_ops kvaser_usb_netdev_ops = {
1365         .ndo_open = kvaser_usb_open,
1366         .ndo_stop = kvaser_usb_close,
1367         .ndo_start_xmit = kvaser_usb_start_xmit,
1368 };
1369
1370 static const struct can_bittiming_const kvaser_usb_bittiming_const = {
1371         .name = "kvaser_usb",
1372         .tseg1_min = KVASER_USB_TSEG1_MIN,
1373         .tseg1_max = KVASER_USB_TSEG1_MAX,
1374         .tseg2_min = KVASER_USB_TSEG2_MIN,
1375         .tseg2_max = KVASER_USB_TSEG2_MAX,
1376         .sjw_max = KVASER_USB_SJW_MAX,
1377         .brp_min = KVASER_USB_BRP_MIN,
1378         .brp_max = KVASER_USB_BRP_MAX,
1379         .brp_inc = KVASER_USB_BRP_INC,
1380 };
1381
1382 static int kvaser_usb_set_bittiming(struct net_device *netdev)
1383 {
1384         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1385         struct can_bittiming *bt = &priv->can.bittiming;
1386         struct kvaser_usb *dev = priv->dev;
1387         struct kvaser_msg *msg;
1388         int rc;
1389
1390         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1391         if (!msg)
1392                 return -ENOMEM;
1393
1394         msg->id = CMD_SET_BUS_PARAMS;
1395         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_busparams);
1396         msg->u.busparams.channel = priv->channel;
1397         msg->u.busparams.tid = 0xff;
1398         msg->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
1399         msg->u.busparams.sjw = bt->sjw;
1400         msg->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
1401         msg->u.busparams.tseg2 = bt->phase_seg2;
1402
1403         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1404                 msg->u.busparams.no_samp = 3;
1405         else
1406                 msg->u.busparams.no_samp = 1;
1407
1408         rc = kvaser_usb_send_msg(dev, msg);
1409
1410         kfree(msg);
1411         return rc;
1412 }
1413
1414 static int kvaser_usb_set_mode(struct net_device *netdev,
1415                                enum can_mode mode)
1416 {
1417         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1418         int err;
1419
1420         switch (mode) {
1421         case CAN_MODE_START:
1422                 err = kvaser_usb_simple_msg_async(priv, CMD_START_CHIP);
1423                 if (err)
1424                         return err;
1425                 break;
1426         default:
1427                 return -EOPNOTSUPP;
1428         }
1429
1430         return 0;
1431 }
1432
1433 static int kvaser_usb_get_berr_counter(const struct net_device *netdev,
1434                                        struct can_berr_counter *bec)
1435 {
1436         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1437
1438         *bec = priv->bec;
1439
1440         return 0;
1441 }
1442
1443 static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev)
1444 {
1445         int i;
1446
1447         for (i = 0; i < dev->nchannels; i++) {
1448                 if (!dev->nets[i])
1449                         continue;
1450
1451                 unregister_netdev(dev->nets[i]->netdev);
1452         }
1453
1454         kvaser_usb_unlink_all_urbs(dev);
1455
1456         for (i = 0; i < dev->nchannels; i++) {
1457                 if (!dev->nets[i])
1458                         continue;
1459
1460                 free_candev(dev->nets[i]->netdev);
1461         }
1462 }
1463
1464 static int kvaser_usb_init_one(struct usb_interface *intf,
1465                                const struct usb_device_id *id, int channel)
1466 {
1467         struct kvaser_usb *dev = usb_get_intfdata(intf);
1468         struct net_device *netdev;
1469         struct kvaser_usb_net_priv *priv;
1470         int i, err;
1471
1472         netdev = alloc_candev(sizeof(*priv), MAX_TX_URBS);
1473         if (!netdev) {
1474                 dev_err(&intf->dev, "Cannot alloc candev\n");
1475                 return -ENOMEM;
1476         }
1477
1478         priv = netdev_priv(netdev);
1479
1480         init_completion(&priv->start_comp);
1481         init_completion(&priv->stop_comp);
1482
1483         init_usb_anchor(&priv->tx_submitted);
1484         atomic_set(&priv->active_tx_urbs, 0);
1485
1486         for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++)
1487                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
1488
1489         priv->dev = dev;
1490         priv->netdev = netdev;
1491         priv->channel = channel;
1492
1493         priv->can.state = CAN_STATE_STOPPED;
1494         priv->can.clock.freq = CAN_USB_CLOCK;
1495         priv->can.bittiming_const = &kvaser_usb_bittiming_const;
1496         priv->can.do_set_bittiming = kvaser_usb_set_bittiming;
1497         priv->can.do_set_mode = kvaser_usb_set_mode;
1498         if (id->driver_info & KVASER_HAS_TXRX_ERRORS)
1499                 priv->can.do_get_berr_counter = kvaser_usb_get_berr_counter;
1500         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
1501         if (id->driver_info & KVASER_HAS_SILENT_MODE)
1502                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
1503
1504         netdev->flags |= IFF_ECHO;
1505
1506         netdev->netdev_ops = &kvaser_usb_netdev_ops;
1507
1508         SET_NETDEV_DEV(netdev, &intf->dev);
1509
1510         dev->nets[channel] = priv;
1511
1512         err = register_candev(netdev);
1513         if (err) {
1514                 dev_err(&intf->dev, "Failed to register can device\n");
1515                 free_candev(netdev);
1516                 dev->nets[channel] = NULL;
1517                 return err;
1518         }
1519
1520         netdev_dbg(netdev, "device registered\n");
1521
1522         return 0;
1523 }
1524
1525 static void kvaser_usb_get_endpoints(const struct usb_interface *intf,
1526                                      struct usb_endpoint_descriptor **in,
1527                                      struct usb_endpoint_descriptor **out)
1528 {
1529         const struct usb_host_interface *iface_desc;
1530         struct usb_endpoint_descriptor *endpoint;
1531         int i;
1532
1533         iface_desc = &intf->altsetting[0];
1534
1535         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1536                 endpoint = &iface_desc->endpoint[i].desc;
1537
1538                 if (usb_endpoint_is_bulk_in(endpoint))
1539                         *in = endpoint;
1540
1541                 if (usb_endpoint_is_bulk_out(endpoint))
1542                         *out = endpoint;
1543         }
1544 }
1545
1546 static int kvaser_usb_probe(struct usb_interface *intf,
1547                             const struct usb_device_id *id)
1548 {
1549         struct kvaser_usb *dev;
1550         int err = -ENOMEM;
1551         int i;
1552
1553         dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL);
1554         if (!dev)
1555                 return -ENOMEM;
1556
1557         kvaser_usb_get_endpoints(intf, &dev->bulk_in, &dev->bulk_out);
1558         if (!dev->bulk_in || !dev->bulk_out) {
1559                 dev_err(&intf->dev, "Cannot get usb endpoint(s)");
1560                 return err;
1561         }
1562
1563         dev->udev = interface_to_usbdev(intf);
1564
1565         init_usb_anchor(&dev->rx_submitted);
1566
1567         usb_set_intfdata(intf, dev);
1568
1569         for (i = 0; i < MAX_NET_DEVICES; i++)
1570                 kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, i);
1571
1572         err = kvaser_usb_get_software_info(dev);
1573         if (err) {
1574                 dev_err(&intf->dev,
1575                         "Cannot get software infos, error %d\n", err);
1576                 return err;
1577         }
1578
1579         err = kvaser_usb_get_card_info(dev);
1580         if (err) {
1581                 dev_err(&intf->dev,
1582                         "Cannot get card infos, error %d\n", err);
1583                 return err;
1584         }
1585
1586         dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n",
1587                 ((dev->fw_version >> 24) & 0xff),
1588                 ((dev->fw_version >> 16) & 0xff),
1589                 (dev->fw_version & 0xffff));
1590
1591         for (i = 0; i < dev->nchannels; i++) {
1592                 err = kvaser_usb_init_one(intf, id, i);
1593                 if (err) {
1594                         kvaser_usb_remove_interfaces(dev);
1595                         return err;
1596                 }
1597         }
1598
1599         return 0;
1600 }
1601
1602 static void kvaser_usb_disconnect(struct usb_interface *intf)
1603 {
1604         struct kvaser_usb *dev = usb_get_intfdata(intf);
1605
1606         usb_set_intfdata(intf, NULL);
1607
1608         if (!dev)
1609                 return;
1610
1611         kvaser_usb_remove_interfaces(dev);
1612 }
1613
1614 static struct usb_driver kvaser_usb_driver = {
1615         .name = "kvaser_usb",
1616         .probe = kvaser_usb_probe,
1617         .disconnect = kvaser_usb_disconnect,
1618         .id_table = kvaser_usb_table,
1619 };
1620
1621 module_usb_driver(kvaser_usb_driver);
1622
1623 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
1624 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
1625 MODULE_LICENSE("GPL v2");