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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * CAN driver for PEAK System PCAN-USB Pro adapter
   4  * Derived from the PCAN project file driver/src/pcan_usbpro.c
   5  *
   6  * Copyright (C) 2003-2011 PEAK System-Technik GmbH
   7  * Copyright (C) 2011-2012 Stephane Grosjean <[email protected]>
   8  */
   9 #include <linux/ethtool.h>
  10 #include <linux/module.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/usb.h>
  13
  14 #include <linux/can.h>
  15 #include <linux/can/dev.h>
  16 #include <linux/can/error.h>
  17
  18 #include "pcan_usb_core.h"
  19 #include "pcan_usb_pro.h"
  20
  21 #define PCAN_USBPRO_CHANNEL_COUNT       2
  22
  23 /* PCAN-USB Pro adapter internal clock (MHz) */
  24 #define PCAN_USBPRO_CRYSTAL_HZ          56000000
  25
  26 /* PCAN-USB Pro command timeout (ms.) */
  27 #define PCAN_USBPRO_COMMAND_TIMEOUT     1000
  28
  29 /* PCAN-USB Pro rx/tx buffers size */
  30 #define PCAN_USBPRO_RX_BUFFER_SIZE      1024
  31 #define PCAN_USBPRO_TX_BUFFER_SIZE      64
  32
  33 #define PCAN_USBPRO_MSG_HEADER_LEN      4
  34
  35 /* some commands responses need to be re-submitted */
  36 #define PCAN_USBPRO_RSP_SUBMIT_MAX      2
  37
  38 #define PCAN_USBPRO_RTR                 0x01
  39 #define PCAN_USBPRO_EXT                 0x02
  40 #define PCAN_USBPRO_SS                  0x08
  41
  42 #define PCAN_USBPRO_CMD_BUFFER_SIZE     512
  43
  44 /* handle device specific info used by the netdevices */
  45 struct pcan_usb_pro_interface {
  46         struct peak_usb_device *dev[PCAN_USBPRO_CHANNEL_COUNT];
  47         struct peak_time_ref time_ref;
  48         int cm_ignore_count;
  49         int dev_opened_count;
  50 };
  51
  52 /* device information */
  53 struct pcan_usb_pro_device {
  54         struct peak_usb_device dev;
  55         struct pcan_usb_pro_interface *usb_if;
  56         u32 cached_ccbt;
  57 };
  58
  59 /* internal structure used to handle messages sent to bulk urb */
  60 struct pcan_usb_pro_msg {
  61         u8 *rec_ptr;
  62         int rec_buffer_size;
  63         int rec_buffer_len;
  64         union {
  65                 __le16 *rec_cnt_rd;
  66                 __le32 *rec_cnt;
  67                 u8 *rec_buffer;
  68         } u;
  69 };
  70
  71 /* records sizes table indexed on message id. (8-bits value) */
  72 static u16 pcan_usb_pro_sizeof_rec[256] = {
  73         [PCAN_USBPRO_SETBTR] = sizeof(struct pcan_usb_pro_btr),
  74         [PCAN_USBPRO_SETBUSACT] = sizeof(struct pcan_usb_pro_busact),
  75         [PCAN_USBPRO_SETSILENT] = sizeof(struct pcan_usb_pro_silent),
  76         [PCAN_USBPRO_SETFILTR] = sizeof(struct pcan_usb_pro_filter),
  77         [PCAN_USBPRO_SETTS] = sizeof(struct pcan_usb_pro_setts),
  78         [PCAN_USBPRO_GETDEVID] = sizeof(struct pcan_usb_pro_devid),
  79         [PCAN_USBPRO_SETDEVID] = sizeof(struct pcan_usb_pro_devid),
  80         [PCAN_USBPRO_SETLED] = sizeof(struct pcan_usb_pro_setled),
  81         [PCAN_USBPRO_RXMSG8] = sizeof(struct pcan_usb_pro_rxmsg),
  82         [PCAN_USBPRO_RXMSG4] = sizeof(struct pcan_usb_pro_rxmsg) - 4,
  83         [PCAN_USBPRO_RXMSG0] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
  84         [PCAN_USBPRO_RXRTR] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
  85         [PCAN_USBPRO_RXSTATUS] = sizeof(struct pcan_usb_pro_rxstatus),
  86         [PCAN_USBPRO_RXTS] = sizeof(struct pcan_usb_pro_rxts),
  87         [PCAN_USBPRO_TXMSG8] = sizeof(struct pcan_usb_pro_txmsg),
  88         [PCAN_USBPRO_TXMSG4] = sizeof(struct pcan_usb_pro_txmsg) - 4,
  89         [PCAN_USBPRO_TXMSG0] = sizeof(struct pcan_usb_pro_txmsg) - 8,
  90 };
  91
  92 /*
  93  * initialize PCAN-USB Pro message data structure
  94  */
  95 static u8 *pcan_msg_init(struct pcan_usb_pro_msg *pm, void *buffer_addr,
  96                          int buffer_size)
  97 {
  98         if (buffer_size < PCAN_USBPRO_MSG_HEADER_LEN)
  99                 return NULL;
 100
 101         pm->u.rec_buffer = (u8 *)buffer_addr;
 102         pm->rec_buffer_size = pm->rec_buffer_len = buffer_size;
 103         pm->rec_ptr = pm->u.rec_buffer + PCAN_USBPRO_MSG_HEADER_LEN;
 104
 105         return pm->rec_ptr;
 106 }
 107
 108 static u8 *pcan_msg_init_empty(struct pcan_usb_pro_msg *pm,
 109                                void *buffer_addr, int buffer_size)
 110 {
 111         u8 *pr = pcan_msg_init(pm, buffer_addr, buffer_size);
 112
 113         if (pr) {
 114                 pm->rec_buffer_len = PCAN_USBPRO_MSG_HEADER_LEN;
 115                 *pm->u.rec_cnt = 0;
 116         }
 117         return pr;
 118 }
 119
 120 /*
 121  * add one record to a message being built
 122  */
 123 static int pcan_msg_add_rec(struct pcan_usb_pro_msg *pm, int id, ...)
 124 {
 125         int len, i;
 126         u8 *pc;
 127         va_list ap;
 128
 129         va_start(ap, id);
 130
 131         pc = pm->rec_ptr + 1;
 132
 133         i = 0;
 134         switch (id) {
 135         case PCAN_USBPRO_TXMSG8:
 136                 i += 4;
 137                 fallthrough;
 138         case PCAN_USBPRO_TXMSG4:
 139                 i += 4;
 140                 fallthrough;
 141         case PCAN_USBPRO_TXMSG0:
 142                 *pc++ = va_arg(ap, int);
 143                 *pc++ = va_arg(ap, int);
 144                 *pc++ = va_arg(ap, int);
 145                 *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
 146                 pc += 4;
 147                 memcpy(pc, va_arg(ap, int *), i);
 148                 pc += i;
 149                 break;
 150
 151         case PCAN_USBPRO_SETBTR:
 152         case PCAN_USBPRO_GETDEVID:
 153         case PCAN_USBPRO_SETDEVID:
 154                 *pc++ = va_arg(ap, int);
 155                 pc += 2;
 156                 *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
 157                 pc += 4;
 158                 break;
 159
 160         case PCAN_USBPRO_SETFILTR:
 161         case PCAN_USBPRO_SETBUSACT:
 162         case PCAN_USBPRO_SETSILENT:
 163                 *pc++ = va_arg(ap, int);
 164                 *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
 165                 pc += 2;
 166                 break;
 167
 168         case PCAN_USBPRO_SETLED:
 169                 *pc++ = va_arg(ap, int);
 170                 *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
 171                 pc += 2;
 172                 *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
 173                 pc += 4;
 174                 break;
 175
 176         case PCAN_USBPRO_SETTS:
 177                 pc++;
 178                 *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
 179                 pc += 2;
 180                 break;
 181
 182         default:
 183                 pr_err("%s: %s(): unknown data type %02Xh (%d)\n",
 184                         PCAN_USB_DRIVER_NAME, __func__, id, id);
 185                 pc--;
 186                 break;
 187         }
 188
 189         len = pc - pm->rec_ptr;
 190         if (len > 0) {
 191                 le32_add_cpu(pm->u.rec_cnt, 1);
 192                 *pm->rec_ptr = id;
 193
 194                 pm->rec_ptr = pc;
 195                 pm->rec_buffer_len += len;
 196         }
 197
 198         va_end(ap);
 199
 200         return len;
 201 }
 202
 203 /*
 204  * send PCAN-USB Pro command synchronously
 205  */
 206 static int pcan_usb_pro_send_cmd(struct peak_usb_device *dev,
 207                                  struct pcan_usb_pro_msg *pum)
 208 {
 209         int actual_length;
 210         int err;
 211
 212         /* usb device unregistered? */
 213         if (!(dev->state & PCAN_USB_STATE_CONNECTED))
 214                 return 0;
 215
 216         err = usb_bulk_msg(dev->udev,
 217                 usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
 218                 pum->u.rec_buffer, pum->rec_buffer_len,
 219                 &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
 220         if (err)
 221                 netdev_err(dev->netdev, "sending command failure: %d\n", err);
 222
 223         return err;
 224 }
 225
 226 /*
 227  * wait for PCAN-USB Pro command response
 228  */
 229 static int pcan_usb_pro_wait_rsp(struct peak_usb_device *dev,
 230                                  struct pcan_usb_pro_msg *pum)
 231 {
 232         u8 req_data_type, req_channel;
 233         int actual_length;
 234         int i, err = 0;
 235
 236         /* usb device unregistered? */
 237         if (!(dev->state & PCAN_USB_STATE_CONNECTED))
 238                 return 0;
 239
 240         req_data_type = pum->u.rec_buffer[4];
 241         req_channel = pum->u.rec_buffer[5];
 242
 243         *pum->u.rec_cnt = 0;
 244         for (i = 0; !err && i < PCAN_USBPRO_RSP_SUBMIT_MAX; i++) {
 245                 struct pcan_usb_pro_msg rsp;
 246                 union pcan_usb_pro_rec *pr;
 247                 u32 r, rec_cnt;
 248                 u16 rec_len;
 249                 u8 *pc;
 250
 251                 err = usb_bulk_msg(dev->udev,
 252                         usb_rcvbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDIN),
 253                         pum->u.rec_buffer, pum->rec_buffer_len,
 254                         &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
 255                 if (err) {
 256                         netdev_err(dev->netdev, "waiting rsp error %d\n", err);
 257                         break;
 258                 }
 259
 260                 if (actual_length == 0)
 261                         continue;
 262
 263                 err = -EBADMSG;
 264                 if (actual_length < PCAN_USBPRO_MSG_HEADER_LEN) {
 265                         netdev_err(dev->netdev,
 266                                    "got abnormal too small rsp (len=%d)\n",
 267                                    actual_length);
 268                         break;
 269                 }
 270
 271                 pc = pcan_msg_init(&rsp, pum->u.rec_buffer,
 272                         actual_length);
 273
 274                 rec_cnt = le32_to_cpu(*rsp.u.rec_cnt);
 275
 276                 /* loop on records stored into message */
 277                 for (r = 0; r < rec_cnt; r++) {
 278                         pr = (union pcan_usb_pro_rec *)pc;
 279                         rec_len = pcan_usb_pro_sizeof_rec[pr->data_type];
 280                         if (!rec_len) {
 281                                 netdev_err(dev->netdev,
 282                                            "got unprocessed record in msg\n");
 283                                 pcan_dump_mem("rcvd rsp msg", pum->u.rec_buffer,
 284                                               actual_length);
 285                                 break;
 286                         }
 287
 288                         /* check if response corresponds to request */
 289                         if (pr->data_type != req_data_type)
 290                                 netdev_err(dev->netdev,
 291                                            "got unwanted rsp %xh: ignored\n",
 292                                            pr->data_type);
 293
 294                         /* check if channel in response corresponds too */
 295                         else if ((req_channel != 0xff) &&
 296                                 (pr->bus_act.channel != req_channel))
 297                                 netdev_err(dev->netdev,
 298                                         "got rsp %xh but on chan%u: ignored\n",
 299                                         req_data_type, pr->bus_act.channel);
 300
 301                         /* got the response */
 302                         else
 303                                 return 0;
 304
 305                         /* otherwise, go on with next record in message */
 306                         pc += rec_len;
 307                 }
 308         }
 309
 310         return (i >= PCAN_USBPRO_RSP_SUBMIT_MAX) ? -ERANGE : err;
 311 }
 312
 313 int pcan_usb_pro_send_req(struct peak_usb_device *dev, int req_id,
 314                           int req_value, void *req_addr, int req_size)
 315 {
 316         int err;
 317         u8 req_type;
 318         unsigned int p;
 319
 320         /* usb device unregistered? */
 321         if (!(dev->state & PCAN_USB_STATE_CONNECTED))
 322                 return 0;
 323
 324         req_type = USB_TYPE_VENDOR | USB_RECIP_OTHER;
 325
 326         switch (req_id) {
 327         case PCAN_USBPRO_REQ_FCT:
 328                 p = usb_sndctrlpipe(dev->udev, 0);
 329                 break;
 330
 331         default:
 332                 p = usb_rcvctrlpipe(dev->udev, 0);
 333                 req_type |= USB_DIR_IN;
 334                 memset(req_addr, '\0', req_size);
 335                 break;
 336         }
 337
 338         err = usb_control_msg(dev->udev, p, req_id, req_type, req_value, 0,
 339                               req_addr, req_size, 2 * USB_CTRL_GET_TIMEOUT);
 340         if (err < 0) {
 341                 netdev_info(dev->netdev,
 342                             "unable to request usb[type=%d value=%d] err=%d\n",
 343                             req_id, req_value, err);
 344                 return err;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static int pcan_usb_pro_set_ts(struct peak_usb_device *dev, u16 onoff)
 351 {
 352         struct pcan_usb_pro_msg um;
 353
 354         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 355         pcan_msg_add_rec(&um, PCAN_USBPRO_SETTS, onoff);
 356
 357         return pcan_usb_pro_send_cmd(dev, &um);
 358 }
 359
 360 static int pcan_usb_pro_set_bitrate(struct peak_usb_device *dev, u32 ccbt)
 361 {
 362         struct pcan_usb_pro_device *pdev =
 363                         container_of(dev, struct pcan_usb_pro_device, dev);
 364         struct pcan_usb_pro_msg um;
 365
 366         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 367         pcan_msg_add_rec(&um, PCAN_USBPRO_SETBTR, dev->ctrl_idx, ccbt);
 368
 369         /* cache the CCBT value to reuse it before next buson */
 370         pdev->cached_ccbt = ccbt;
 371
 372         return pcan_usb_pro_send_cmd(dev, &um);
 373 }
 374
 375 static int pcan_usb_pro_set_bus(struct peak_usb_device *dev, u8 onoff)
 376 {
 377         struct pcan_usb_pro_msg um;
 378
 379         /* if bus=on, be sure the bitrate being set before! */
 380         if (onoff) {
 381                 struct pcan_usb_pro_device *pdev =
 382                              container_of(dev, struct pcan_usb_pro_device, dev);
 383
 384                 pcan_usb_pro_set_bitrate(dev, pdev->cached_ccbt);
 385         }
 386
 387         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 388         pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, onoff);
 389
 390         return pcan_usb_pro_send_cmd(dev, &um);
 391 }
 392
 393 static int pcan_usb_pro_set_silent(struct peak_usb_device *dev, u8 onoff)
 394 {
 395         struct pcan_usb_pro_msg um;
 396
 397         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 398         pcan_msg_add_rec(&um, PCAN_USBPRO_SETSILENT, dev->ctrl_idx, onoff);
 399
 400         return pcan_usb_pro_send_cmd(dev, &um);
 401 }
 402
 403 static int pcan_usb_pro_set_filter(struct peak_usb_device *dev, u16 filter_mode)
 404 {
 405         struct pcan_usb_pro_msg um;
 406
 407         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 408         pcan_msg_add_rec(&um, PCAN_USBPRO_SETFILTR, dev->ctrl_idx, filter_mode);
 409
 410         return pcan_usb_pro_send_cmd(dev, &um);
 411 }
 412
 413 static int pcan_usb_pro_set_led(struct peak_usb_device *dev, u8 mode,
 414                                 u32 timeout)
 415 {
 416         struct pcan_usb_pro_msg um;
 417
 418         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 419         pcan_msg_add_rec(&um, PCAN_USBPRO_SETLED, dev->ctrl_idx, mode, timeout);
 420
 421         return pcan_usb_pro_send_cmd(dev, &um);
 422 }
 423
 424 static int pcan_usb_pro_get_can_channel_id(struct peak_usb_device *dev,
 425                                            u32 *can_ch_id)
 426 {
 427         struct pcan_usb_pro_devid *pdn;
 428         struct pcan_usb_pro_msg um;
 429         int err;
 430         u8 *pc;
 431
 432         pc = pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 433         pcan_msg_add_rec(&um, PCAN_USBPRO_GETDEVID, dev->ctrl_idx);
 434
 435         err =  pcan_usb_pro_send_cmd(dev, &um);
 436         if (err)
 437                 return err;
 438
 439         err = pcan_usb_pro_wait_rsp(dev, &um);
 440         if (err)
 441                 return err;
 442
 443         pdn = (struct pcan_usb_pro_devid *)pc;
 444         *can_ch_id = le32_to_cpu(pdn->dev_num);
 445
 446         return err;
 447 }
 448
 449 static int pcan_usb_pro_set_can_channel_id(struct peak_usb_device *dev,
 450                                            u32 can_ch_id)
 451 {
 452         struct pcan_usb_pro_msg um;
 453
 454         pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
 455         pcan_msg_add_rec(&um, PCAN_USBPRO_SETDEVID, dev->ctrl_idx,
 456                          can_ch_id);
 457
 458         return pcan_usb_pro_send_cmd(dev, &um);
 459 }
 460
 461 static int pcan_usb_pro_set_bittiming(struct peak_usb_device *dev,
 462                                       struct can_bittiming *bt)
 463 {
 464         u32 ccbt;
 465
 466         ccbt = (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 0x00800000 : 0;
 467         ccbt |= (bt->sjw - 1) << 24;
 468         ccbt |= (bt->phase_seg2 - 1) << 20;
 469         ccbt |= (bt->prop_seg + bt->phase_seg1 - 1) << 16; /* = tseg1 */
 470         ccbt |= bt->brp - 1;
 471
 472         netdev_info(dev->netdev, "setting ccbt=0x%08x\n", ccbt);
 473
 474         return pcan_usb_pro_set_bitrate(dev, ccbt);
 475 }
 476
 477 void pcan_usb_pro_restart_complete(struct urb *urb)
 478 {
 479         /* can delete usb resources */
 480         peak_usb_async_complete(urb);
 481
 482         /* notify candev and netdev */
 483         peak_usb_restart_complete(urb->context);
 484 }
 485
 486 /*
 487  * handle restart but in asynchronously way
 488  */
 489 static int pcan_usb_pro_restart_async(struct peak_usb_device *dev,
 490                                       struct urb *urb, u8 *buf)
 491 {
 492         struct pcan_usb_pro_msg um;
 493
 494         pcan_msg_init_empty(&um, buf, PCAN_USB_MAX_CMD_LEN);
 495         pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, 1);
 496
 497         usb_fill_bulk_urb(urb, dev->udev,
 498                         usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
 499                         buf, PCAN_USB_MAX_CMD_LEN,
 500                         pcan_usb_pro_restart_complete, dev);
 501
 502         return usb_submit_urb(urb, GFP_ATOMIC);
 503 }
 504
 505 static int pcan_usb_pro_drv_loaded(struct peak_usb_device *dev, int loaded)
 506 {
 507         u8 *buffer;
 508         int err;
 509
 510         buffer = kzalloc(PCAN_USBPRO_FCT_DRVLD_REQ_LEN, GFP_KERNEL);
 511         if (!buffer)
 512                 return -ENOMEM;
 513
 514         buffer[0] = 0;
 515         buffer[1] = !!loaded;
 516
 517         err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_FCT,
 518                                     PCAN_USBPRO_FCT_DRVLD, buffer,
 519                                     PCAN_USBPRO_FCT_DRVLD_REQ_LEN);
 520         kfree(buffer);
 521
 522         return err;
 523 }
 524
 525 static inline
 526 struct pcan_usb_pro_interface *pcan_usb_pro_dev_if(struct peak_usb_device *dev)
 527 {
 528         struct pcan_usb_pro_device *pdev =
 529                         container_of(dev, struct pcan_usb_pro_device, dev);
 530         return pdev->usb_if;
 531 }
 532
 533 static int pcan_usb_pro_handle_canmsg(struct pcan_usb_pro_interface *usb_if,
 534                                       struct pcan_usb_pro_rxmsg *rx)
 535 {
 536         const unsigned int ctrl_idx = (rx->len >> 4) & 0x0f;
 537         struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
 538         struct net_device *netdev = dev->netdev;
 539         struct can_frame *can_frame;
 540         struct sk_buff *skb;
 541         struct skb_shared_hwtstamps *hwts;
 542
 543         skb = alloc_can_skb(netdev, &can_frame);
 544         if (!skb)
 545                 return -ENOMEM;
 546
 547         can_frame->can_id = le32_to_cpu(rx->id);
 548         can_frame->len = rx->len & 0x0f;
 549
 550         if (rx->flags & PCAN_USBPRO_EXT)
 551                 can_frame->can_id |= CAN_EFF_FLAG;
 552
 553         if (rx->flags & PCAN_USBPRO_RTR) {
 554                 can_frame->can_id |= CAN_RTR_FLAG;
 555         } else {
 556                 memcpy(can_frame->data, rx->data, can_frame->len);
 557
 558                 netdev->stats.rx_bytes += can_frame->len;
 559         }
 560         netdev->stats.rx_packets++;
 561
 562         hwts = skb_hwtstamps(skb);
 563         peak_usb_get_ts_time(&usb_if->time_ref, le32_to_cpu(rx->ts32),
 564                              &hwts->hwtstamp);
 565
 566         netif_rx(skb);
 567
 568         return 0;
 569 }
 570
 571 static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if,
 572                                      struct pcan_usb_pro_rxstatus *er)
 573 {
 574         const u16 raw_status = le16_to_cpu(er->status);
 575         const unsigned int ctrl_idx = (er->channel >> 4) & 0x0f;
 576         struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
 577         struct net_device *netdev = dev->netdev;
 578         struct can_frame *can_frame;
 579         enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
 580         u8 err_mask = 0;
 581         struct sk_buff *skb;
 582         struct skb_shared_hwtstamps *hwts;
 583
 584         /* nothing should be sent while in BUS_OFF state */
 585         if (dev->can.state == CAN_STATE_BUS_OFF)
 586                 return 0;
 587
 588         if (!raw_status) {
 589                 /* no error bit (back to active state) */
 590                 dev->can.state = CAN_STATE_ERROR_ACTIVE;
 591                 return 0;
 592         }
 593
 594         if (raw_status & (PCAN_USBPRO_STATUS_OVERRUN |
 595                           PCAN_USBPRO_STATUS_QOVERRUN)) {
 596                 /* trick to bypass next comparison and process other errors */
 597                 new_state = CAN_STATE_MAX;
 598         }
 599
 600         if (raw_status & PCAN_USBPRO_STATUS_BUS) {
 601                 new_state = CAN_STATE_BUS_OFF;
 602         } else if (raw_status & PCAN_USBPRO_STATUS_ERROR) {
 603                 u32 rx_err_cnt = (le32_to_cpu(er->err_frm) & 0x00ff0000) >> 16;
 604                 u32 tx_err_cnt = (le32_to_cpu(er->err_frm) & 0xff000000) >> 24;
 605
 606                 if (rx_err_cnt > 127)
 607                         err_mask |= CAN_ERR_CRTL_RX_PASSIVE;
 608                 else if (rx_err_cnt > 96)
 609                         err_mask |= CAN_ERR_CRTL_RX_WARNING;
 610
 611                 if (tx_err_cnt > 127)
 612                         err_mask |= CAN_ERR_CRTL_TX_PASSIVE;
 613                 else if (tx_err_cnt > 96)
 614                         err_mask |= CAN_ERR_CRTL_TX_WARNING;
 615
 616                 if (err_mask & (CAN_ERR_CRTL_RX_WARNING |
 617                                 CAN_ERR_CRTL_TX_WARNING))
 618                         new_state = CAN_STATE_ERROR_WARNING;
 619                 else if (err_mask & (CAN_ERR_CRTL_RX_PASSIVE |
 620                                      CAN_ERR_CRTL_TX_PASSIVE))
 621                         new_state = CAN_STATE_ERROR_PASSIVE;
 622         }
 623
 624         /* donot post any error if current state didn't change */
 625         if (dev->can.state == new_state)
 626                 return 0;
 627
 628         /* allocate an skb to store the error frame */
 629         skb = alloc_can_err_skb(netdev, &can_frame);
 630         if (!skb)
 631                 return -ENOMEM;
 632
 633         switch (new_state) {
 634         case CAN_STATE_BUS_OFF:
 635                 can_frame->can_id |= CAN_ERR_BUSOFF;
 636                 dev->can.can_stats.bus_off++;
 637                 can_bus_off(netdev);
 638                 break;
 639
 640         case CAN_STATE_ERROR_PASSIVE:
 641                 can_frame->can_id |= CAN_ERR_CRTL;
 642                 can_frame->data[1] |= err_mask;
 643                 dev->can.can_stats.error_passive++;
 644                 break;
 645
 646         case CAN_STATE_ERROR_WARNING:
 647                 can_frame->can_id |= CAN_ERR_CRTL;
 648                 can_frame->data[1] |= err_mask;
 649                 dev->can.can_stats.error_warning++;
 650                 break;
 651
 652         case CAN_STATE_ERROR_ACTIVE:
 653                 break;
 654
 655         default:
 656                 /* CAN_STATE_MAX (trick to handle other errors) */
 657                 if (raw_status & PCAN_USBPRO_STATUS_OVERRUN) {
 658                         can_frame->can_id |= CAN_ERR_PROT;
 659                         can_frame->data[2] |= CAN_ERR_PROT_OVERLOAD;
 660                         netdev->stats.rx_over_errors++;
 661                         netdev->stats.rx_errors++;
 662                 }
 663
 664                 if (raw_status & PCAN_USBPRO_STATUS_QOVERRUN) {
 665                         can_frame->can_id |= CAN_ERR_CRTL;
 666                         can_frame->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
 667                         netdev->stats.rx_over_errors++;
 668                         netdev->stats.rx_errors++;
 669                 }
 670
 671                 new_state = CAN_STATE_ERROR_ACTIVE;
 672                 break;
 673         }
 674
 675         dev->can.state = new_state;
 676
 677         hwts = skb_hwtstamps(skb);
 678         peak_usb_get_ts_time(&usb_if->time_ref, le32_to_cpu(er->ts32), &hwts->hwtstamp);
 679         netif_rx(skb);
 680
 681         return 0;
 682 }
 683
 684 static void pcan_usb_pro_handle_ts(struct pcan_usb_pro_interface *usb_if,
 685                                    struct pcan_usb_pro_rxts *ts)
 686 {
 687         /* should wait until clock is stabilized */
 688         if (usb_if->cm_ignore_count > 0)
 689                 usb_if->cm_ignore_count--;
 690         else
 691                 peak_usb_set_ts_now(&usb_if->time_ref,
 692                                     le32_to_cpu(ts->ts64[1]));
 693 }
 694
 695 /*
 696  * callback for bulk IN urb
 697  */
 698 static int pcan_usb_pro_decode_buf(struct peak_usb_device *dev, struct urb *urb)
 699 {
 700         struct pcan_usb_pro_interface *usb_if = pcan_usb_pro_dev_if(dev);
 701         struct net_device *netdev = dev->netdev;
 702         struct pcan_usb_pro_msg usb_msg;
 703         u8 *rec_ptr, *msg_end;
 704         u16 rec_cnt;
 705         int err = 0;
 706
 707         rec_ptr = pcan_msg_init(&usb_msg, urb->transfer_buffer,
 708                                         urb->actual_length);
 709         if (!rec_ptr) {
 710                 netdev_err(netdev, "bad msg hdr len %d\n", urb->actual_length);
 711                 return -EINVAL;
 712         }
 713
 714         /* loop reading all the records from the incoming message */
 715         msg_end = urb->transfer_buffer + urb->actual_length;
 716         rec_cnt = le16_to_cpu(*usb_msg.u.rec_cnt_rd);
 717         for (; rec_cnt > 0; rec_cnt--) {
 718                 union pcan_usb_pro_rec *pr = (union pcan_usb_pro_rec *)rec_ptr;
 719                 u16 sizeof_rec = pcan_usb_pro_sizeof_rec[pr->data_type];
 720
 721                 if (!sizeof_rec) {
 722                         netdev_err(netdev,
 723                                    "got unsupported rec in usb msg:\n");
 724                         err = -ENOTSUPP;
 725                         break;
 726                 }
 727
 728                 /* check if the record goes out of current packet */
 729                 if (rec_ptr + sizeof_rec > msg_end) {
 730                         netdev_err(netdev,
 731                                 "got frag rec: should inc usb rx buf size\n");
 732                         err = -EBADMSG;
 733                         break;
 734                 }
 735
 736                 switch (pr->data_type) {
 737                 case PCAN_USBPRO_RXMSG8:
 738                 case PCAN_USBPRO_RXMSG4:
 739                 case PCAN_USBPRO_RXMSG0:
 740                 case PCAN_USBPRO_RXRTR:
 741                         err = pcan_usb_pro_handle_canmsg(usb_if, &pr->rx_msg);
 742                         if (err < 0)
 743                                 goto fail;
 744                         break;
 745
 746                 case PCAN_USBPRO_RXSTATUS:
 747                         err = pcan_usb_pro_handle_error(usb_if, &pr->rx_status);
 748                         if (err < 0)
 749                                 goto fail;
 750                         break;
 751
 752                 case PCAN_USBPRO_RXTS:
 753                         pcan_usb_pro_handle_ts(usb_if, &pr->rx_ts);
 754                         break;
 755
 756                 default:
 757                         netdev_err(netdev,
 758                                    "unhandled rec type 0x%02x (%d): ignored\n",
 759                                    pr->data_type, pr->data_type);
 760                         break;
 761                 }
 762
 763                 rec_ptr += sizeof_rec;
 764         }
 765
 766 fail:
 767         if (err)
 768                 pcan_dump_mem("received msg",
 769                               urb->transfer_buffer, urb->actual_length);
 770
 771         return err;
 772 }
 773
 774 static int pcan_usb_pro_encode_msg(struct peak_usb_device *dev,
 775                                    struct sk_buff *skb, u8 *obuf, size_t *size)
 776 {
 777         struct can_frame *cf = (struct can_frame *)skb->data;
 778         u8 data_type, len, flags;
 779         struct pcan_usb_pro_msg usb_msg;
 780
 781         pcan_msg_init_empty(&usb_msg, obuf, *size);
 782
 783         if ((cf->can_id & CAN_RTR_FLAG) || (cf->len == 0))
 784                 data_type = PCAN_USBPRO_TXMSG0;
 785         else if (cf->len <= 4)
 786                 data_type = PCAN_USBPRO_TXMSG4;
 787         else
 788                 data_type = PCAN_USBPRO_TXMSG8;
 789
 790         len = (dev->ctrl_idx << 4) | (cf->len & 0x0f);
 791
 792         flags = 0;
 793         if (cf->can_id & CAN_EFF_FLAG)
 794                 flags |= PCAN_USBPRO_EXT;
 795         if (cf->can_id & CAN_RTR_FLAG)
 796                 flags |= PCAN_USBPRO_RTR;
 797
 798         /* Single-Shot frame */
 799         if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
 800                 flags |= PCAN_USBPRO_SS;
 801
 802         pcan_msg_add_rec(&usb_msg, data_type, 0, flags, len, cf->can_id,
 803                          cf->data);
 804
 805         *size = usb_msg.rec_buffer_len;
 806
 807         return 0;
 808 }
 809
 810 static int pcan_usb_pro_start(struct peak_usb_device *dev)
 811 {
 812         struct pcan_usb_pro_device *pdev =
 813                         container_of(dev, struct pcan_usb_pro_device, dev);
 814         int err;
 815
 816         err = pcan_usb_pro_set_silent(dev,
 817                                 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
 818         if (err)
 819                 return err;
 820
 821         /* filter mode: 0-> All OFF; 1->bypass */
 822         err = pcan_usb_pro_set_filter(dev, 1);
 823         if (err)
 824                 return err;
 825
 826         /* opening first device: */
 827         if (pdev->usb_if->dev_opened_count == 0) {
 828                 /* reset time_ref */
 829                 peak_usb_init_time_ref(&pdev->usb_if->time_ref, &pcan_usb_pro);
 830
 831                 /* ask device to send ts messages */
 832                 err = pcan_usb_pro_set_ts(dev, 1);
 833         }
 834
 835         pdev->usb_if->dev_opened_count++;
 836
 837         return err;
 838 }
 839
 840 /*
 841  * stop interface
 842  * (last chance before set bus off)
 843  */
 844 static int pcan_usb_pro_stop(struct peak_usb_device *dev)
 845 {
 846         struct pcan_usb_pro_device *pdev =
 847                         container_of(dev, struct pcan_usb_pro_device, dev);
 848
 849         /* turn off ts msgs for that interface if no other dev opened */
 850         if (pdev->usb_if->dev_opened_count == 1)
 851                 pcan_usb_pro_set_ts(dev, 0);
 852
 853         pdev->usb_if->dev_opened_count--;
 854
 855         return 0;
 856 }
 857
 858 /*
 859  * called when probing to initialize a device object.
 860  */
 861 static int pcan_usb_pro_init(struct peak_usb_device *dev)
 862 {
 863         struct pcan_usb_pro_device *pdev =
 864                         container_of(dev, struct pcan_usb_pro_device, dev);
 865         struct pcan_usb_pro_interface *usb_if = NULL;
 866         struct pcan_usb_pro_fwinfo *fi = NULL;
 867         struct pcan_usb_pro_blinfo *bi = NULL;
 868         int err;
 869
 870         /* do this for 1st channel only */
 871         if (!dev->prev_siblings) {
 872                 /* allocate netdevices common structure attached to first one */
 873                 usb_if = kzalloc(sizeof(struct pcan_usb_pro_interface),
 874                                  GFP_KERNEL);
 875                 fi = kmalloc(sizeof(struct pcan_usb_pro_fwinfo), GFP_KERNEL);
 876                 bi = kmalloc(sizeof(struct pcan_usb_pro_blinfo), GFP_KERNEL);
 877                 if (!usb_if || !fi || !bi) {
 878                         err = -ENOMEM;
 879                         goto err_out;
 880                 }
 881
 882                 /* number of ts msgs to ignore before taking one into account */
 883                 usb_if->cm_ignore_count = 5;
 884
 885                 /*
 886                  * explicit use of dev_xxx() instead of netdev_xxx() here:
 887                  * information displayed are related to the device itself, not
 888                  * to the canx netdevices.
 889                  */
 890                 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
 891                                             PCAN_USBPRO_INFO_FW,
 892                                             fi, sizeof(*fi));
 893                 if (err) {
 894                         dev_err(dev->netdev->dev.parent,
 895                                 "unable to read %s firmware info (err %d)\n",
 896                                 pcan_usb_pro.name, err);
 897                         goto err_out;
 898                 }
 899
 900                 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
 901                                             PCAN_USBPRO_INFO_BL,
 902                                             bi, sizeof(*bi));
 903                 if (err) {
 904                         dev_err(dev->netdev->dev.parent,
 905                                 "unable to read %s bootloader info (err %d)\n",
 906                                 pcan_usb_pro.name, err);
 907                         goto err_out;
 908                 }
 909
 910                 /* tell the device the can driver is running */
 911                 err = pcan_usb_pro_drv_loaded(dev, 1);
 912                 if (err)
 913                         goto err_out;
 914
 915                 dev_info(dev->netdev->dev.parent,
 916                      "PEAK-System %s hwrev %u serial %08X.%08X (%u channels)\n",
 917                      pcan_usb_pro.name,
 918                      bi->hw_rev, bi->serial_num_hi, bi->serial_num_lo,
 919                      pcan_usb_pro.ctrl_count);
 920         } else {
 921                 usb_if = pcan_usb_pro_dev_if(dev->prev_siblings);
 922         }
 923
 924         pdev->usb_if = usb_if;
 925         usb_if->dev[dev->ctrl_idx] = dev;
 926
 927         /* set LED in default state (end of init phase) */
 928         pcan_usb_pro_set_led(dev, PCAN_USBPRO_LED_DEVICE, 1);
 929
 930         kfree(bi);
 931         kfree(fi);
 932
 933         return 0;
 934
 935  err_out:
 936         kfree(bi);
 937         kfree(fi);
 938         kfree(usb_if);
 939
 940         return err;
 941 }
 942
 943 static void pcan_usb_pro_exit(struct peak_usb_device *dev)
 944 {
 945         struct pcan_usb_pro_device *pdev =
 946                         container_of(dev, struct pcan_usb_pro_device, dev);
 947
 948         /*
 949          * when rmmod called before unplug and if down, should reset things
 950          * before leaving
 951          */
 952         if (dev->can.state != CAN_STATE_STOPPED) {
 953                 /* set bus off on the corresponding channel */
 954                 pcan_usb_pro_set_bus(dev, 0);
 955         }
 956
 957         /* if channel #0 (only) */
 958         if (dev->ctrl_idx == 0) {
 959                 /* turn off calibration message if any device were opened */
 960                 if (pdev->usb_if->dev_opened_count > 0)
 961                         pcan_usb_pro_set_ts(dev, 0);
 962
 963                 /* tell the PCAN-USB Pro device the driver is being unloaded */
 964                 pcan_usb_pro_drv_loaded(dev, 0);
 965         }
 966 }
 967
 968 /*
 969  * called when PCAN-USB Pro adapter is unplugged
 970  */
 971 static void pcan_usb_pro_free(struct peak_usb_device *dev)
 972 {
 973         /* last device: can free pcan_usb_pro_interface object now */
 974         if (!dev->prev_siblings && !dev->next_siblings)
 975                 kfree(pcan_usb_pro_dev_if(dev));
 976 }
 977
 978 /*
 979  * probe function for new PCAN-USB Pro usb interface
 980  */
 981 int pcan_usb_pro_probe(struct usb_interface *intf)
 982 {
 983         struct usb_host_interface *if_desc;
 984         int i;
 985
 986         if_desc = intf->altsetting;
 987
 988         /* check interface endpoint addresses */
 989         for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
 990                 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
 991
 992                 /*
 993                  * below is the list of valid ep addresses. Any other ep address
 994                  * is considered as not-CAN interface address => no dev created
 995                  */
 996                 switch (ep->bEndpointAddress) {
 997                 case PCAN_USBPRO_EP_CMDOUT:
 998                 case PCAN_USBPRO_EP_CMDIN:
 999                 case PCAN_USBPRO_EP_MSGOUT_0:
1000                 case PCAN_USBPRO_EP_MSGOUT_1:
1001                 case PCAN_USBPRO_EP_MSGIN:
1002                 case PCAN_USBPRO_EP_UNUSED:
1003                         break;
1004                 default:
1005                         return -ENODEV;
1006                 }
1007         }
1008
1009         return 0;
1010 }
1011
1012 static int pcan_usb_pro_set_phys_id(struct net_device *netdev,
1013                                     enum ethtool_phys_id_state state)
1014 {
1015         struct peak_usb_device *dev = netdev_priv(netdev);
1016         int err = 0;
1017
1018         switch (state) {
1019         case ETHTOOL_ID_ACTIVE:
1020                 /* fast blinking forever */
1021                 err = pcan_usb_pro_set_led(dev, PCAN_USBPRO_LED_BLINK_FAST,
1022                                            0xffffffff);
1023                 break;
1024
1025         case ETHTOOL_ID_INACTIVE:
1026                 /* restore LED default */
1027                 err = pcan_usb_pro_set_led(dev, PCAN_USBPRO_LED_DEVICE, 1);
1028                 break;
1029
1030         default:
1031                 break;
1032         }
1033
1034         return err;
1035 }
1036
1037 static const struct ethtool_ops pcan_usb_pro_ethtool_ops = {
1038         .set_phys_id = pcan_usb_pro_set_phys_id,
1039         .get_ts_info = pcan_get_ts_info,
1040         .get_eeprom_len = peak_usb_get_eeprom_len,
1041         .get_eeprom = peak_usb_get_eeprom,
1042         .set_eeprom = peak_usb_set_eeprom,
1043 };
1044
1045 /*
1046  * describe the PCAN-USB Pro adapter
1047  */
1048 static const struct can_bittiming_const pcan_usb_pro_const = {
1049         .name = "pcan_usb_pro",
1050         .tseg1_min = 1,
1051         .tseg1_max = 16,
1052         .tseg2_min = 1,
1053         .tseg2_max = 8,
1054         .sjw_max = 4,
1055         .brp_min = 1,
1056         .brp_max = 1024,
1057         .brp_inc = 1,
1058 };
1059
1060 const struct peak_usb_adapter pcan_usb_pro = {
1061         .name = "PCAN-USB Pro",
1062         .device_id = PCAN_USBPRO_PRODUCT_ID,
1063         .ctrl_count = PCAN_USBPRO_CHANNEL_COUNT,
1064         .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY |
1065                               CAN_CTRLMODE_ONE_SHOT,
1066         .clock = {
1067                 .freq = PCAN_USBPRO_CRYSTAL_HZ,
1068         },
1069         .bittiming_const = &pcan_usb_pro_const,
1070
1071         /* size of device private data */
1072         .sizeof_dev_private = sizeof(struct pcan_usb_pro_device),
1073
1074         .ethtool_ops = &pcan_usb_pro_ethtool_ops,
1075
1076         /* timestamps usage */
1077         .ts_used_bits = 32,
1078         .us_per_ts_scale = 1, /* us = (ts * scale) >> shift */
1079         .us_per_ts_shift = 0,
1080
1081         /* give here messages in/out endpoints */
1082         .ep_msg_in = PCAN_USBPRO_EP_MSGIN,
1083         .ep_msg_out = {PCAN_USBPRO_EP_MSGOUT_0, PCAN_USBPRO_EP_MSGOUT_1},
1084
1085         /* size of rx/tx usb buffers */
1086         .rx_buffer_size = PCAN_USBPRO_RX_BUFFER_SIZE,
1087         .tx_buffer_size = PCAN_USBPRO_TX_BUFFER_SIZE,
1088
1089         /* device callbacks */
1090         .intf_probe = pcan_usb_pro_probe,
1091         .dev_init = pcan_usb_pro_init,
1092         .dev_exit = pcan_usb_pro_exit,
1093         .dev_free = pcan_usb_pro_free,
1094         .dev_set_bus = pcan_usb_pro_set_bus,
1095         .dev_set_bittiming = pcan_usb_pro_set_bittiming,
1096         .dev_get_can_channel_id = pcan_usb_pro_get_can_channel_id,
1097         .dev_set_can_channel_id = pcan_usb_pro_set_can_channel_id,
1098         .dev_decode_buf = pcan_usb_pro_decode_buf,
1099         .dev_encode_msg = pcan_usb_pro_encode_msg,
1100         .dev_start = pcan_usb_pro_start,
1101         .dev_stop = pcan_usb_pro_stop,
1102         .dev_restart_async = pcan_usb_pro_restart_async,
1103 };