LXR linux/drivers/net/can/usb/peak_usb/pcan

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * CAN driver for PEAK System PCAN-USB adapter
   4 * Derived from the PCAN project file driver/src/pcan_usb.c
   5 *
   6 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
   7 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
   8 *
   9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
  10 */
  11#include <linux/netdevice.h>
  12#include <linux/usb.h>
  13#include <linux/module.h>
  14
  15#include <linux/can.h>
  16#include <linux/can/dev.h>
  17#include <linux/can/error.h>
  18
  19#include "pcan_usb_core.h"
  20
  21MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB adapter");
  22
  23/* PCAN-USB Endpoints */
  24#define PCAN_USB_EP_CMDOUT              1
  25#define PCAN_USB_EP_CMDIN               (PCAN_USB_EP_CMDOUT | USB_DIR_IN)
  26#define PCAN_USB_EP_MSGOUT              2
  27#define PCAN_USB_EP_MSGIN               (PCAN_USB_EP_MSGOUT | USB_DIR_IN)
  28
  29/* PCAN-USB command struct */
  30#define PCAN_USB_CMD_FUNC               0
  31#define PCAN_USB_CMD_NUM                1
  32#define PCAN_USB_CMD_ARGS               2
  33#define PCAN_USB_CMD_ARGS_LEN           14
  34#define PCAN_USB_CMD_LEN                (PCAN_USB_CMD_ARGS + \
  35                                         PCAN_USB_CMD_ARGS_LEN)
  36
  37/* PCAN-USB command timeout (ms.) */
  38#define PCAN_USB_COMMAND_TIMEOUT        1000
  39
  40/* PCAN-USB startup timeout (ms.) */
  41#define PCAN_USB_STARTUP_TIMEOUT        10
  42
  43/* PCAN-USB rx/tx buffers size */
  44#define PCAN_USB_RX_BUFFER_SIZE         64
  45#define PCAN_USB_TX_BUFFER_SIZE         64
  46
  47#define PCAN_USB_MSG_HEADER_LEN         2
  48
  49/* PCAN-USB adapter internal clock (MHz) */
  50#define PCAN_USB_CRYSTAL_HZ             16000000
  51
  52/* PCAN-USB USB message record status/len field */
  53#define PCAN_USB_STATUSLEN_TIMESTAMP    (1 << 7)
  54#define PCAN_USB_STATUSLEN_INTERNAL     (1 << 6)
  55#define PCAN_USB_STATUSLEN_EXT_ID       (1 << 5)
  56#define PCAN_USB_STATUSLEN_RTR          (1 << 4)
  57#define PCAN_USB_STATUSLEN_DLC          (0xf)
  58
  59/* PCAN-USB error flags */
  60#define PCAN_USB_ERROR_TXFULL           0x01
  61#define PCAN_USB_ERROR_RXQOVR           0x02
  62#define PCAN_USB_ERROR_BUS_LIGHT        0x04
  63#define PCAN_USB_ERROR_BUS_HEAVY        0x08
  64#define PCAN_USB_ERROR_BUS_OFF          0x10
  65#define PCAN_USB_ERROR_RXQEMPTY         0x20
  66#define PCAN_USB_ERROR_QOVR             0x40
  67#define PCAN_USB_ERROR_TXQFULL          0x80
  68
  69/* SJA1000 modes */
  70#define SJA1000_MODE_NORMAL             0x00
  71#define SJA1000_MODE_INIT               0x01
  72
  73/*
  74 * tick duration = 42.666 us =>
  75 * (tick_number * 44739243) >> 20 ~ (tick_number * 42666) / 1000
  76 * accuracy = 10^-7
  77 */
  78#define PCAN_USB_TS_DIV_SHIFTER         20
  79#define PCAN_USB_TS_US_PER_TICK         44739243
  80
  81/* PCAN-USB messages record types */
  82#define PCAN_USB_REC_ERROR              1
  83#define PCAN_USB_REC_ANALOG             2
  84#define PCAN_USB_REC_BUSLOAD            3
  85#define PCAN_USB_REC_TS                 4
  86#define PCAN_USB_REC_BUSEVT             5
  87
  88/* private to PCAN-USB adapter */
  89struct pcan_usb {
  90        struct peak_usb_device dev;
  91        struct peak_time_ref time_ref;
  92        struct timer_list restart_timer;
  93};
  94
  95/* incoming message context for decoding */
  96struct pcan_usb_msg_context {
  97        u16 ts16;
  98        u8 prev_ts8;
  99        u8 *ptr;
 100        u8 *end;
 101        u8 rec_cnt;
 102        u8 rec_idx;
 103        u8 rec_ts_idx;
 104        struct net_device *netdev;
 105        struct pcan_usb *pdev;
 106};
 107
 108/*
 109 * send a command
 110 */
 111static int pcan_usb_send_cmd(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
 112{
 113        int err;
 114        int actual_length;
 115
 116        /* usb device unregistered? */
 117        if (!(dev->state & PCAN_USB_STATE_CONNECTED))
 118                return 0;
 119
 120        dev->cmd_buf[PCAN_USB_CMD_FUNC] = f;
 121        dev->cmd_buf[PCAN_USB_CMD_NUM] = n;
 122
 123        if (p)
 124                memcpy(dev->cmd_buf + PCAN_USB_CMD_ARGS,
 125                        p, PCAN_USB_CMD_ARGS_LEN);
 126
 127        err = usb_bulk_msg(dev->udev,
 128                        usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
 129                        dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,
 130                        PCAN_USB_COMMAND_TIMEOUT);
 131        if (err)
 132                netdev_err(dev->netdev,
 133                        "sending cmd f=0x%x n=0x%x failure: %d\n",
 134                        f, n, err);
 135        return err;
 136}
 137
 138/*
 139 * send a command then wait for its response
 140 */
 141static int pcan_usb_wait_rsp(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
 142{
 143        int err;
 144        int actual_length;
 145
 146        /* usb device unregistered? */
 147        if (!(dev->state & PCAN_USB_STATE_CONNECTED))
 148                return 0;
 149
 150        /* first, send command */
 151        err = pcan_usb_send_cmd(dev, f, n, NULL);
 152        if (err)
 153                return err;
 154
 155        err = usb_bulk_msg(dev->udev,
 156                usb_rcvbulkpipe(dev->udev, PCAN_USB_EP_CMDIN),
 157                dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,
 158                PCAN_USB_COMMAND_TIMEOUT);
 159        if (err)
 160                netdev_err(dev->netdev,
 161                        "waiting rsp f=0x%x n=0x%x failure: %d\n", f, n, err);
 162        else if (p)
 163                memcpy(p, dev->cmd_buf + PCAN_USB_CMD_ARGS,
 164                        PCAN_USB_CMD_ARGS_LEN);
 165
 166        return err;
 167}
 168
 169static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode)
 170{
 171        u8 args[PCAN_USB_CMD_ARGS_LEN] = {
 172                [1] = mode,
 173        };
 174
 175        return pcan_usb_send_cmd(dev, 9, 2, args);
 176}
 177
 178static int pcan_usb_set_bus(struct peak_usb_device *dev, u8 onoff)
 179{
 180        u8 args[PCAN_USB_CMD_ARGS_LEN] = {
 181                [0] = !!onoff,
 182        };
 183
 184        return pcan_usb_send_cmd(dev, 3, 2, args);
 185}
 186
 187static int pcan_usb_set_silent(struct peak_usb_device *dev, u8 onoff)
 188{
 189        u8 args[PCAN_USB_CMD_ARGS_LEN] = {
 190                [0] = !!onoff,
 191        };
 192
 193        return pcan_usb_send_cmd(dev, 3, 3, args);
 194}
 195
 196static int pcan_usb_set_ext_vcc(struct peak_usb_device *dev, u8 onoff)
 197{
 198        u8 args[PCAN_USB_CMD_ARGS_LEN] = {
 199                [0] = !!onoff,
 200        };
 201
 202        return pcan_usb_send_cmd(dev, 10, 2, args);
 203}
 204
 205/*
 206 * set bittiming value to can
 207 */
 208static int pcan_usb_set_bittiming(struct peak_usb_device *dev,
 209                                  struct can_bittiming *bt)
 210{
 211        u8 args[PCAN_USB_CMD_ARGS_LEN];
 212        u8 btr0, btr1;
 213
 214        btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
 215        btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
 216                (((bt->phase_seg2 - 1) & 0x7) << 4);
 217        if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 218                btr1 |= 0x80;
 219
 220        netdev_info(dev->netdev, "setting BTR0=0x%02x BTR1=0x%02x\n",
 221                btr0, btr1);
 222
 223        args[0] = btr1;
 224        args[1] = btr0;
 225
 226        return pcan_usb_send_cmd(dev, 1, 2, args);
 227}
 228
 229/*
 230 * init/reset can
 231 */
 232static int pcan_usb_write_mode(struct peak_usb_device *dev, u8 onoff)
 233{
 234        int err;
 235
 236        err = pcan_usb_set_bus(dev, onoff);
 237        if (err)
 238                return err;
 239
 240        if (!onoff) {
 241                err = pcan_usb_set_sja1000(dev, SJA1000_MODE_INIT);
 242        } else {
 243                /* the PCAN-USB needs time to init */
 244                set_current_state(TASK_INTERRUPTIBLE);
 245                schedule_timeout(msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
 246        }
 247
 248        return err;
 249}
 250
 251/*
 252 * handle end of waiting for the device to reset
 253 */
 254static void pcan_usb_restart(struct timer_list *t)
 255{
 256        struct pcan_usb *pdev = from_timer(pdev, t, restart_timer);
 257        struct peak_usb_device *dev = &pdev->dev;
 258
 259        /* notify candev and netdev */
 260        peak_usb_restart_complete(dev);
 261}
 262
 263/*
 264 * handle the submission of the restart urb
 265 */
 266static void pcan_usb_restart_pending(struct urb *urb)
 267{
 268        struct pcan_usb *pdev = urb->context;
 269
 270        /* the PCAN-USB needs time to restart */
 271        mod_timer(&pdev->restart_timer,
 272                        jiffies + msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
 273
 274        /* can delete usb resources */
 275        peak_usb_async_complete(urb);
 276}
 277
 278/*
 279 * handle asynchronous restart
 280 */
 281static int pcan_usb_restart_async(struct peak_usb_device *dev, struct urb *urb,
 282                                  u8 *buf)
 283{
 284        struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
 285
 286        if (timer_pending(&pdev->restart_timer))
 287                return -EBUSY;
 288
 289        /* set bus on */
 290        buf[PCAN_USB_CMD_FUNC] = 3;
 291        buf[PCAN_USB_CMD_NUM] = 2;
 292        buf[PCAN_USB_CMD_ARGS] = 1;
 293
 294        usb_fill_bulk_urb(urb, dev->udev,
 295                        usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
 296                        buf, PCAN_USB_CMD_LEN,
 297                        pcan_usb_restart_pending, pdev);
 298
 299        return usb_submit_urb(urb, GFP_ATOMIC);
 300}
 301
 302/*
 303 * read serial number from device
 304 */
 305static int pcan_usb_get_serial(struct peak_usb_device *dev, u32 *serial_number)
 306{
 307        u8 args[PCAN_USB_CMD_ARGS_LEN];
 308        int err;
 309
 310        err = pcan_usb_wait_rsp(dev, 6, 1, args);
 311        if (err) {
 312                netdev_err(dev->netdev, "getting serial failure: %d\n", err);
 313        } else if (serial_number) {
 314                __le32 tmp32;
 315
 316                memcpy(&tmp32, args, 4);
 317                *serial_number = le32_to_cpu(tmp32);
 318        }
 319
 320        return err;
 321}
 322
 323/*
 324 * read device id from device
 325 */
 326static int pcan_usb_get_device_id(struct peak_usb_device *dev, u32 *device_id)
 327{
 328        u8 args[PCAN_USB_CMD_ARGS_LEN];
 329        int err;
 330
 331        err = pcan_usb_wait_rsp(dev, 4, 1, args);
 332        if (err)
 333                netdev_err(dev->netdev, "getting device id failure: %d\n", err);
 334        else if (device_id)
 335                *device_id = args[0];
 336
 337        return err;
 338}
 339
 340/*
 341 * update current time ref with received timestamp
 342 */
 343static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc)
 344{
 345        __le16 tmp16;
 346
 347        if ((mc->ptr+2) > mc->end)
 348                return -EINVAL;
 349
 350        memcpy(&tmp16, mc->ptr, 2);
 351
 352        mc->ts16 = le16_to_cpu(tmp16);
 353
 354        if (mc->rec_idx > 0)
 355                peak_usb_update_ts_now(&mc->pdev->time_ref, mc->ts16);
 356        else
 357                peak_usb_set_ts_now(&mc->pdev->time_ref, mc->ts16);
 358
 359        return 0;
 360}
 361
 362/*
 363 * decode received timestamp
 364 */
 365static int pcan_usb_decode_ts(struct pcan_usb_msg_context *mc, u8 first_packet)
 366{
 367        /* only 1st packet supplies a word timestamp */
 368        if (first_packet) {
 369                __le16 tmp16;
 370
 371                if ((mc->ptr + 2) > mc->end)
 372                        return -EINVAL;
 373
 374                memcpy(&tmp16, mc->ptr, 2);
 375                mc->ptr += 2;
 376
 377                mc->ts16 = le16_to_cpu(tmp16);
 378                mc->prev_ts8 = mc->ts16 & 0x00ff;
 379        } else {
 380                u8 ts8;
 381
 382                if ((mc->ptr + 1) > mc->end)
 383                        return -EINVAL;
 384
 385                ts8 = *mc->ptr++;
 386
 387                if (ts8 < mc->prev_ts8)
 388                        mc->ts16 += 0x100;
 389
 390                mc->ts16 &= 0xff00;
 391                mc->ts16 |= ts8;
 392                mc->prev_ts8 = ts8;
 393        }
 394
 395        return 0;
 396}
 397
 398static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
 399                                 u8 status_len)
 400{
 401        struct sk_buff *skb;
 402        struct can_frame *cf;
 403        enum can_state new_state;
 404
 405        /* ignore this error until 1st ts received */
 406        if (n == PCAN_USB_ERROR_QOVR)
 407                if (!mc->pdev->time_ref.tick_count)
 408                        return 0;
 409
 410        new_state = mc->pdev->dev.can.state;
 411
 412        switch (mc->pdev->dev.can.state) {
 413        case CAN_STATE_ERROR_ACTIVE:
 414                if (n & PCAN_USB_ERROR_BUS_LIGHT) {
 415                        new_state = CAN_STATE_ERROR_WARNING;
 416                        break;
 417                }
 418                fallthrough;
 419
 420        case CAN_STATE_ERROR_WARNING:
 421                if (n & PCAN_USB_ERROR_BUS_HEAVY) {
 422                        new_state = CAN_STATE_ERROR_PASSIVE;
 423                        break;
 424                }
 425                if (n & PCAN_USB_ERROR_BUS_OFF) {
 426                        new_state = CAN_STATE_BUS_OFF;
 427                        break;
 428                }
 429                if (n & (PCAN_USB_ERROR_RXQOVR | PCAN_USB_ERROR_QOVR)) {
 430                        /*
 431                         * trick to bypass next comparison and process other
 432                         * errors
 433                         */
 434                        new_state = CAN_STATE_MAX;
 435                        break;
 436                }
 437                if ((n & PCAN_USB_ERROR_BUS_LIGHT) == 0) {
 438                        /* no error (back to active state) */
 439                        new_state = CAN_STATE_ERROR_ACTIVE;
 440                        break;
 441                }
 442                break;
 443
 444        case CAN_STATE_ERROR_PASSIVE:
 445                if (n & PCAN_USB_ERROR_BUS_OFF) {
 446                        new_state = CAN_STATE_BUS_OFF;
 447                        break;
 448                }
 449                if (n & PCAN_USB_ERROR_BUS_LIGHT) {
 450                        new_state = CAN_STATE_ERROR_WARNING;
 451                        break;
 452                }
 453                if (n & (PCAN_USB_ERROR_RXQOVR | PCAN_USB_ERROR_QOVR)) {
 454                        /*
 455                         * trick to bypass next comparison and process other
 456                         * errors
 457                         */
 458                        new_state = CAN_STATE_MAX;
 459                        break;
 460                }
 461
 462                if ((n & PCAN_USB_ERROR_BUS_HEAVY) == 0) {
 463                        /* no error (back to warning state) */
 464                        new_state = CAN_STATE_ERROR_WARNING;
 465                        break;
 466                }
 467                break;
 468
 469        default:
 470                /* do nothing waiting for restart */
 471                return 0;
 472        }
 473
 474        /* donot post any error if current state didn't change */
 475        if (mc->pdev->dev.can.state == new_state)
 476                return 0;
 477
 478        /* allocate an skb to store the error frame */
 479        skb = alloc_can_err_skb(mc->netdev, &cf);
 480        if (!skb)
 481                return -ENOMEM;
 482
 483        switch (new_state) {
 484        case CAN_STATE_BUS_OFF:
 485                cf->can_id |= CAN_ERR_BUSOFF;
 486                mc->pdev->dev.can.can_stats.bus_off++;
 487                can_bus_off(mc->netdev);
 488                break;
 489
 490        case CAN_STATE_ERROR_PASSIVE:
 491                cf->can_id |= CAN_ERR_CRTL;
 492                cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE |
 493                               CAN_ERR_CRTL_RX_PASSIVE;
 494                mc->pdev->dev.can.can_stats.error_passive++;
 495                break;
 496
 497        case CAN_STATE_ERROR_WARNING:
 498                cf->can_id |= CAN_ERR_CRTL;
 499                cf->data[1] |= CAN_ERR_CRTL_TX_WARNING |
 500                               CAN_ERR_CRTL_RX_WARNING;
 501                mc->pdev->dev.can.can_stats.error_warning++;
 502                break;
 503
 504        case CAN_STATE_ERROR_ACTIVE:
 505                cf->can_id |= CAN_ERR_CRTL;
 506                cf->data[1] = CAN_ERR_CRTL_ACTIVE;
 507                break;
 508
 509        default:
 510                /* CAN_STATE_MAX (trick to handle other errors) */
 511                cf->can_id |= CAN_ERR_CRTL;
 512                cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
 513                mc->netdev->stats.rx_over_errors++;
 514                mc->netdev->stats.rx_errors++;
 515
 516                new_state = mc->pdev->dev.can.state;
 517                break;
 518        }
 519
 520        mc->pdev->dev.can.state = new_state;
 521
 522        if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
 523                struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
 524
 525                peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16,
 526                                     &hwts->hwtstamp);
 527        }
 528
 529        mc->netdev->stats.rx_packets++;
 530        mc->netdev->stats.rx_bytes += cf->can_dlc;
 531        netif_rx(skb);
 532
 533        return 0;
 534}
 535
 536/*
 537 * decode non-data usb message
 538 */
 539static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,
 540                                  u8 status_len)
 541{
 542        u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
 543        u8 f, n;
 544        int err;
 545
 546        /* check whether function and number can be read */
 547        if ((mc->ptr + 2) > mc->end)
 548                return -EINVAL;
 549
 550        f = mc->ptr[PCAN_USB_CMD_FUNC];
 551        n = mc->ptr[PCAN_USB_CMD_NUM];
 552        mc->ptr += PCAN_USB_CMD_ARGS;
 553
 554        if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
 555                int err = pcan_usb_decode_ts(mc, !mc->rec_ts_idx);
 556
 557                if (err)
 558                        return err;
 559
 560                /* Next packet in the buffer will have a timestamp on a single
 561                 * byte
 562                 */
 563                mc->rec_ts_idx++;
 564        }
 565
 566        switch (f) {
 567        case PCAN_USB_REC_ERROR:
 568                err = pcan_usb_decode_error(mc, n, status_len);
 569                if (err)
 570                        return err;
 571                break;
 572
 573        case PCAN_USB_REC_ANALOG:
 574                /* analog values (ignored) */
 575                rec_len = 2;
 576                break;
 577
 578        case PCAN_USB_REC_BUSLOAD:
 579                /* bus load (ignored) */
 580                rec_len = 1;
 581                break;
 582
 583        case PCAN_USB_REC_TS:
 584                /* only timestamp */
 585                if (pcan_usb_update_ts(mc))
 586                        return -EINVAL;
 587                break;
 588
 589        case PCAN_USB_REC_BUSEVT:
 590                /* error frame/bus event */
 591                if (n & PCAN_USB_ERROR_TXQFULL)
 592                        netdev_dbg(mc->netdev, "device Tx queue full)\n");
 593                break;
 594        default:
 595                netdev_err(mc->netdev, "unexpected function %u\n", f);
 596                break;
 597        }
 598
 599        if ((mc->ptr + rec_len) > mc->end)
 600                return -EINVAL;
 601
 602        mc->ptr += rec_len;
 603
 604        return 0;
 605}
 606
 607/*
 608 * decode data usb message
 609 */
 610static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
 611{
 612        u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
 613        struct sk_buff *skb;
 614        struct can_frame *cf;
 615        struct skb_shared_hwtstamps *hwts;
 616
 617        skb = alloc_can_skb(mc->netdev, &cf);
 618        if (!skb)
 619                return -ENOMEM;
 620
 621        if (status_len & PCAN_USB_STATUSLEN_EXT_ID) {
 622                __le32 tmp32;
 623
 624                if ((mc->ptr + 4) > mc->end)
 625                        goto decode_failed;
 626
 627                memcpy(&tmp32, mc->ptr, 4);
 628                mc->ptr += 4;
 629
 630                cf->can_id = (le32_to_cpu(tmp32) >> 3) | CAN_EFF_FLAG;
 631        } else {
 632                __le16 tmp16;
 633
 634                if ((mc->ptr + 2) > mc->end)
 635                        goto decode_failed;
 636
 637                memcpy(&tmp16, mc->ptr, 2);
 638                mc->ptr += 2;
 639
 640                cf->can_id = le16_to_cpu(tmp16) >> 5;
 641        }
 642
 643        cf->can_dlc = get_can_dlc(rec_len);
 644
 645        /* Only first packet timestamp is a word */
 646        if (pcan_usb_decode_ts(mc, !mc->rec_ts_idx))
 647                goto decode_failed;
 648
 649        /* Next packet in the buffer will have a timestamp on a single byte */
 650        mc->rec_ts_idx++;
 651
 652        /* read data */
 653        memset(cf->data, 0x0, sizeof(cf->data));
 654        if (status_len & PCAN_USB_STATUSLEN_RTR) {
 655                cf->can_id |= CAN_RTR_FLAG;
 656        } else {
 657                if ((mc->ptr + rec_len) > mc->end)
 658                        goto decode_failed;
 659
 660                memcpy(cf->data, mc->ptr, cf->can_dlc);
 661                mc->ptr += rec_len;
 662        }
 663
 664        /* convert timestamp into kernel time */
 665        hwts = skb_hwtstamps(skb);
 666        peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, &hwts->hwtstamp);
 667
 668        /* update statistics */
 669        mc->netdev->stats.rx_packets++;
 670        mc->netdev->stats.rx_bytes += cf->can_dlc;
 671        /* push the skb */
 672        netif_rx(skb);
 673
 674        return 0;
 675
 676decode_failed:
 677        dev_kfree_skb(skb);
 678        return -EINVAL;
 679}
 680
 681/*
 682 * process incoming message
 683 */
 684static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf)
 685{
 686        struct pcan_usb_msg_context mc = {
 687                .rec_cnt = ibuf[1],
 688                .ptr = ibuf + PCAN_USB_MSG_HEADER_LEN,
 689                .end = ibuf + lbuf,
 690                .netdev = dev->netdev,
 691                .pdev = container_of(dev, struct pcan_usb, dev),
 692        };
 693        int err;
 694
 695        for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) {
 696                u8 sl = *mc.ptr++;
 697
 698                /* handle status and error frames here */
 699                if (sl & PCAN_USB_STATUSLEN_INTERNAL) {
 700                        err = pcan_usb_decode_status(&mc, sl);
 701                /* handle normal can frames here */
 702                } else {
 703                        err = pcan_usb_decode_data(&mc, sl);
 704                }
 705        }
 706
 707        return err;
 708}
 709
 710/*
 711 * process any incoming buffer
 712 */
 713static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb)
 714{
 715        int err = 0;
 716
 717        if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) {
 718                err = pcan_usb_decode_msg(dev, urb->transfer_buffer,
 719                        urb->actual_length);
 720
 721        } else if (urb->actual_length > 0) {
 722                netdev_err(dev->netdev, "usb message length error (%u)\n",
 723                        urb->actual_length);
 724                err = -EINVAL;
 725        }
 726
 727        return err;
 728}
 729
 730/*
 731 * process outgoing packet
 732 */
 733static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb,
 734                               u8 *obuf, size_t *size)
 735{
 736        struct net_device *netdev = dev->netdev;
 737        struct net_device_stats *stats = &netdev->stats;
 738        struct can_frame *cf = (struct can_frame *)skb->data;
 739        u8 *pc;
 740
 741        obuf[0] = 2;
 742        obuf[1] = 1;
 743
 744        pc = obuf + PCAN_USB_MSG_HEADER_LEN;
 745
 746        /* status/len byte */
 747        *pc = cf->can_dlc;
 748        if (cf->can_id & CAN_RTR_FLAG)
 749                *pc |= PCAN_USB_STATUSLEN_RTR;
 750
 751        /* can id */
 752        if (cf->can_id & CAN_EFF_FLAG) {
 753                __le32 tmp32 = cpu_to_le32((cf->can_id & CAN_ERR_MASK) << 3);
 754
 755                *pc |= PCAN_USB_STATUSLEN_EXT_ID;
 756                memcpy(++pc, &tmp32, 4);
 757                pc += 4;
 758        } else {
 759                __le16 tmp16 = cpu_to_le16((cf->can_id & CAN_ERR_MASK) << 5);
 760
 761                memcpy(++pc, &tmp16, 2);
 762                pc += 2;
 763        }
 764
 765        /* can data */
 766        if (!(cf->can_id & CAN_RTR_FLAG)) {
 767                memcpy(pc, cf->data, cf->can_dlc);
 768                pc += cf->can_dlc;
 769        }
 770
 771        obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff);
 772
 773        return 0;
 774}
 775
 776/*
 777 * start interface
 778 */
 779static int pcan_usb_start(struct peak_usb_device *dev)
 780{
 781        struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
 782
 783        /* number of bits used in timestamps read from adapter struct */
 784        peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb);
 785
 786        /* if revision greater than 3, can put silent mode on/off */
 787        if (dev->device_rev > 3) {
 788                int err;
 789
 790                err = pcan_usb_set_silent(dev,
 791                                dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
 792                if (err)
 793                        return err;
 794        }
 795
 796        return pcan_usb_set_ext_vcc(dev, 0);
 797}
 798
 799static int pcan_usb_init(struct peak_usb_device *dev)
 800{
 801        struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
 802        u32 serial_number;
 803        int err;
 804
 805        /* initialize a timer needed to wait for hardware restart */
 806        timer_setup(&pdev->restart_timer, pcan_usb_restart, 0);
 807
 808        /*
 809         * explicit use of dev_xxx() instead of netdev_xxx() here:
 810         * information displayed are related to the device itself, not
 811         * to the canx netdevice.
 812         */
 813        err = pcan_usb_get_serial(dev, &serial_number);
 814        if (err) {
 815                dev_err(dev->netdev->dev.parent,
 816                        "unable to read %s serial number (err %d)\n",
 817                        pcan_usb.name, err);
 818                return err;
 819        }
 820
 821        dev_info(dev->netdev->dev.parent,
 822                 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n",
 823                 pcan_usb.name, dev->device_rev, serial_number,
 824                 pcan_usb.ctrl_count);
 825
 826        return 0;
 827}
 828
 829/*
 830 * probe function for new PCAN-USB usb interface
 831 */
 832static int pcan_usb_probe(struct usb_interface *intf)
 833{
 834        struct usb_host_interface *if_desc;
 835        int i;
 836
 837        if_desc = intf->altsetting;
 838
 839        /* check interface endpoint addresses */
 840        for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
 841                struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
 842
 843                switch (ep->bEndpointAddress) {
 844                case PCAN_USB_EP_CMDOUT:
 845                case PCAN_USB_EP_CMDIN:
 846                case PCAN_USB_EP_MSGOUT:
 847                case PCAN_USB_EP_MSGIN:
 848                        break;
 849                default:
 850                        return -ENODEV;
 851                }
 852        }
 853
 854        return 0;
 855}
 856
 857/*
 858 * describe the PCAN-USB adapter
 859 */
 860static const struct can_bittiming_const pcan_usb_const = {
 861        .name = "pcan_usb",
 862        .tseg1_min = 1,
 863        .tseg1_max = 16,
 864        .tseg2_min = 1,
 865        .tseg2_max = 8,
 866        .sjw_max = 4,
 867        .brp_min = 1,
 868        .brp_max = 64,
 869        .brp_inc = 1,
 870};
 871
 872const struct peak_usb_adapter pcan_usb = {
 873        .name = "PCAN-USB",
 874        .device_id = PCAN_USB_PRODUCT_ID,
 875        .ctrl_count = 1,
 876        .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY,
 877        .clock = {
 878                .freq = PCAN_USB_CRYSTAL_HZ / 2 ,
 879        },
 880        .bittiming_const = &pcan_usb_const,
 881
 882        /* size of device private data */
 883        .sizeof_dev_private = sizeof(struct pcan_usb),
 884
 885        /* timestamps usage */
 886        .ts_used_bits = 16,
 887        .ts_period = 24575, /* calibration period in ts. */
 888        .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */
 889        .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /*  >> shift     */
 890
 891        /* give here messages in/out endpoints */
 892        .ep_msg_in = PCAN_USB_EP_MSGIN,
 893        .ep_msg_out = {PCAN_USB_EP_MSGOUT},
 894
 895        /* size of rx/tx usb buffers */
 896        .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,
 897        .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,
 898
 899        /* device callbacks */
 900        .intf_probe = pcan_usb_probe,
 901        .dev_init = pcan_usb_init,
 902        .dev_set_bus = pcan_usb_write_mode,
 903        .dev_set_bittiming = pcan_usb_set_bittiming,
 904        .dev_get_device_id = pcan_usb_get_device_id,
 905        .dev_decode_buf = pcan_usb_decode_buf,
 906        .dev_encode_msg = pcan_usb_encode_msg,
 907        .dev_start = pcan_usb_start,
 908        .dev_restart_async = pcan_usb_restart_async,
 909};
 910