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

1001        /* timestamps usage */
1002        .ts_used_bits = 16,
1003        .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */
1004        .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /*  >> shift     */
1005
1006        /* give here messages in/out endpoints */
1007        .ep_msg_in = PCAN_USB_EP_MSGIN,
1008        .ep_msg_out = {PCAN_USB_EP_MSGOUT},
1009
1010        /* size of rx/tx usb buffers */
1011        .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,
1012        .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,
1013
1014        /* device callbacks */
1015        .intf_probe = pcan_usb_probe,
1016        .dev_init = pcan_usb_init,
1017        .dev_set_bus = pcan_usb_write_mode,
1018        .dev_set_bittiming = pcan_usb_set_bittiming,
1019        .dev_get_device_id = pcan_usb_get_device_id,
1020        .dev_decode_buf = pcan_usb_decode_buf,
1021        .dev_encode_msg = pcan_usb_encode_msg,
1022        .dev_start = pcan_usb_start,
1023        .dev_restart_async = pcan_usb_restart_async,
1024        .do_get_berr_counter = pcan_usb_get_berr_counter,
1025};
1026