drivers/net/can/usb/peak_usb/pcan_usb.c

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