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

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