drivers/net/can/usb/esd_usb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * CAN driver for esd electronics gmbh CAN-USB/2, CAN-USB/3 and CAN-USB/Micro
   4  *
   5  * Copyright (C) 2010-2012 esd electronic system design gmbh, Matthias Fuchs <[email protected]>
   6  * Copyright (C) 2022-2023 esd electronics gmbh, Frank Jungclaus <[email protected]>
   7  */
   8
   9 #include <linux/can.h>
  10 #include <linux/can/dev.h>
  11 #include <linux/can/error.h>
  12 #include <linux/ethtool.h>
  13 #include <linux/module.h>
  14 #include <linux/netdevice.h>
  15 #include <linux/signal.h>
  16 #include <linux/slab.h>
  17 #include <linux/units.h>
  18 #include <linux/usb.h>
  19
  20 MODULE_AUTHOR("Matthias Fuchs <[email protected]>");
  21 MODULE_AUTHOR("Frank Jungclaus <[email protected]>");
  22 MODULE_DESCRIPTION("CAN driver for esd electronics gmbh CAN-USB/2, CAN-USB/3 and CAN-USB/Micro interfaces");
  23 MODULE_LICENSE("GPL v2");
  24
  25 /* USB vendor and product ID */
  26 #define ESD_USB_ESDGMBH_VENDOR_ID       0x0ab4
  27 #define ESD_USB_CANUSB2_PRODUCT_ID      0x0010
  28 #define ESD_USB_CANUSBM_PRODUCT_ID      0x0011
  29 #define ESD_USB_CANUSB3_PRODUCT_ID      0x0014
  30
  31 /* CAN controller clock frequencies */
  32 #define ESD_USB_2_CAN_CLOCK     (60 * MEGA) /* Hz */
  33 #define ESD_USB_M_CAN_CLOCK     (36 * MEGA) /* Hz */
  34 #define ESD_USB_3_CAN_CLOCK     (80 * MEGA) /* Hz */
  35
  36 /* Maximum number of CAN nets */
  37 #define ESD_USB_MAX_NETS        2
  38
  39 /* USB commands */
  40 #define ESD_USB_CMD_VERSION             1 /* also used for VERSION_REPLY */
  41 #define ESD_USB_CMD_CAN_RX              2 /* device to host only */
  42 #define ESD_USB_CMD_CAN_TX              3 /* also used for TX_DONE */
  43 #define ESD_USB_CMD_SETBAUD             4 /* also used for SETBAUD_REPLY */
  44 #define ESD_USB_CMD_TS                  5 /* also used for TS_REPLY */
  45 #define ESD_USB_CMD_IDADD               6 /* also used for IDADD_REPLY */
  46
  47 /* esd CAN message flags - dlc field */
  48 #define ESD_USB_RTR     BIT(4)
  49 #define ESD_USB_NO_BRS  BIT(4)
  50 #define ESD_USB_ESI     BIT(5)
  51 #define ESD_USB_FD      BIT(7)
  52
  53 /* esd CAN message flags - id field */
  54 #define ESD_USB_EXTID   BIT(29)
  55 #define ESD_USB_EVENT   BIT(30)
  56 #define ESD_USB_IDMASK  GENMASK(28, 0)
  57
  58 /* esd CAN event ids */
  59 #define ESD_USB_EV_CAN_ERROR_EXT        2 /* CAN controller specific diagnostic data */
  60
  61 /* baudrate message flags */
  62 #define ESD_USB_LOM     BIT(30) /* Listen Only Mode */
  63 #define ESD_USB_UBR     BIT(31) /* User Bit Rate (controller BTR) in bits 0..27 */
  64 #define ESD_USB_NO_BAUDRATE     GENMASK(30, 0) /* bit rate unconfigured */
  65
  66 /* bit timing esd CAN-USB */
  67 #define ESD_USB_2_TSEG1_SHIFT   16
  68 #define ESD_USB_2_TSEG2_SHIFT   20
  69 #define ESD_USB_2_SJW_SHIFT     14
  70 #define ESD_USB_M_SJW_SHIFT     24
  71 #define ESD_USB_TRIPLE_SAMPLES  BIT(23)
  72
  73 /* Transmitter Delay Compensation */
  74 #define ESD_USB_3_TDC_MODE_AUTO 0
  75
  76 /* esd IDADD message */
  77 #define ESD_USB_ID_ENABLE       BIT(7)
  78 #define ESD_USB_MAX_ID_SEGMENT  64
  79
  80 /* SJA1000 ECC register (emulated by usb firmware) */
  81 #define ESD_USB_SJA1000_ECC_SEG         GENMASK(4, 0)
  82 #define ESD_USB_SJA1000_ECC_DIR         BIT(5)
  83 #define ESD_USB_SJA1000_ECC_ERR         BIT(2, 1)
  84 #define ESD_USB_SJA1000_ECC_BIT         0x00
  85 #define ESD_USB_SJA1000_ECC_FORM        BIT(6)
  86 #define ESD_USB_SJA1000_ECC_STUFF       BIT(7)
  87 #define ESD_USB_SJA1000_ECC_MASK        GENMASK(7, 6)
  88
  89 /* esd bus state event codes */
  90 #define ESD_USB_BUSSTATE_MASK   GENMASK(7, 6)
  91 #define ESD_USB_BUSSTATE_WARN   BIT(6)
  92 #define ESD_USB_BUSSTATE_ERRPASSIVE     BIT(7)
  93 #define ESD_USB_BUSSTATE_BUSOFF GENMASK(7, 6)
  94
  95 #define ESD_USB_RX_BUFFER_SIZE          1024
  96 #define ESD_USB_MAX_RX_URBS             4
  97 #define ESD_USB_MAX_TX_URBS             16 /* must be power of 2 */
  98
  99 /* Modes for CAN-USB/3, to be used for esd_usb_3_set_baudrate_msg_x.mode */
 100 #define ESD_USB_3_BAUDRATE_MODE_DISABLE         0 /* remove from bus */
 101 #define ESD_USB_3_BAUDRATE_MODE_INDEX           1 /* ESD (CiA) bit rate idx */
 102 #define ESD_USB_3_BAUDRATE_MODE_BTR_CTRL        2 /* BTR values (controller)*/
 103 #define ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL   3 /* BTR values (canonical) */
 104 #define ESD_USB_3_BAUDRATE_MODE_NUM             4 /* numerical bit rate */
 105 #define ESD_USB_3_BAUDRATE_MODE_AUTOBAUD        5 /* autobaud */
 106
 107 /* Flags for CAN-USB/3, to be used for esd_usb_3_set_baudrate_msg_x.flags */
 108 #define ESD_USB_3_BAUDRATE_FLAG_FD      BIT(0) /* enable CAN FD mode */
 109 #define ESD_USB_3_BAUDRATE_FLAG_LOM     BIT(1) /* enable listen only mode */
 110 #define ESD_USB_3_BAUDRATE_FLAG_STM     BIT(2) /* enable self test mode */
 111 #define ESD_USB_3_BAUDRATE_FLAG_TRS     BIT(3) /* enable triple sampling */
 112 #define ESD_USB_3_BAUDRATE_FLAG_TXP     BIT(4) /* enable transmit pause */
 113
 114 struct esd_usb_header_msg {
 115         u8 len; /* total message length in 32bit words */
 116         u8 cmd;
 117         u8 rsvd[2];
 118 };
 119
 120 struct esd_usb_version_msg {
 121         u8 len; /* total message length in 32bit words */
 122         u8 cmd;
 123         u8 rsvd;
 124         u8 flags;
 125         __le32 drv_version;
 126 };
 127
 128 struct esd_usb_version_reply_msg {
 129         u8 len; /* total message length in 32bit words */
 130         u8 cmd;
 131         u8 nets;
 132         u8 features;
 133         __le32 version;
 134         u8 name[16];
 135         __le32 rsvd;
 136         __le32 ts;
 137 };
 138
 139 struct esd_usb_rx_msg {
 140         u8 len; /* total message length in 32bit words */
 141         u8 cmd;
 142         u8 net;
 143         u8 dlc;
 144         __le32 ts;
 145         __le32 id; /* upper 3 bits contain flags */
 146         union {
 147                 u8 data[CAN_MAX_DLEN];
 148                 u8 data_fd[CANFD_MAX_DLEN];
 149                 struct {
 150                         u8 status; /* CAN Controller Status */
 151                         u8 ecc;    /* Error Capture Register */
 152                         u8 rec;    /* RX Error Counter */
 153                         u8 tec;    /* TX Error Counter */
 154                 } ev_can_err_ext;  /* For ESD_EV_CAN_ERROR_EXT */
 155         };
 156 };
 157
 158 struct esd_usb_tx_msg {
 159         u8 len; /* total message length in 32bit words */
 160         u8 cmd;
 161         u8 net;
 162         u8 dlc;
 163         u32 hnd;        /* opaque handle, not used by device */
 164         __le32 id; /* upper 3 bits contain flags */
 165         union {
 166                 u8 data[CAN_MAX_DLEN];
 167                 u8 data_fd[CANFD_MAX_DLEN];
 168         };
 169 };
 170
 171 struct esd_usb_tx_done_msg {
 172         u8 len; /* total message length in 32bit words */
 173         u8 cmd;
 174         u8 net;
 175         u8 status;
 176         u32 hnd;        /* opaque handle, not used by device */
 177         __le32 ts;
 178 };
 179
 180 struct esd_usb_id_filter_msg {
 181         u8 len; /* total message length in 32bit words */
 182         u8 cmd;
 183         u8 net;
 184         u8 option;
 185         __le32 mask[ESD_USB_MAX_ID_SEGMENT + 1]; /* +1 for 29bit extended IDs */
 186 };
 187
 188 struct esd_usb_set_baudrate_msg {
 189         u8 len; /* total message length in 32bit words */
 190         u8 cmd;
 191         u8 net;
 192         u8 rsvd;
 193         __le32 baud;
 194 };
 195
 196 /* CAN-USB/3 baudrate configuration, used for nominal as well as for data bit rate */
 197 struct esd_usb_3_baudrate_cfg {
 198         __le16 brp;     /* bit rate pre-scaler */
 199         __le16 tseg1;   /* time segment before sample point */
 200         __le16 tseg2;   /* time segment after sample point */
 201         __le16 sjw;     /* synchronization jump Width */
 202 };
 203
 204 /* In principle, the esd CAN-USB/3 supports Transmitter Delay Compensation (TDC),
 205  * but currently only the automatic TDC mode is supported by this driver.
 206  * An implementation for manual TDC configuration will follow.
 207  *
 208  * For information about struct esd_usb_3_tdc_cfg, see
 209  * NTCAN Application Developers Manual, 6.2.25 NTCAN_TDC_CFG + related chapters
 210  * https://esd.eu/fileadmin/esd/docs/manuals/NTCAN_Part1_Function_API_Manual_en_56.pdf
 211  */
 212 struct esd_usb_3_tdc_cfg {
 213         u8 tdc_mode;    /* transmitter delay compensation mode  */
 214         u8 ssp_offset;  /* secondary sample point offset in mtq */
 215         s8 ssp_shift;   /* secondary sample point shift in mtq */
 216         u8 tdc_filter;  /* TDC filter in mtq */
 217 };
 218
 219 /* Extended version of the above set_baudrate_msg for a CAN-USB/3
 220  * to define the CAN bit timing configuration of the CAN controller in
 221  * CAN FD mode as well as in Classical CAN mode.
 222  *
 223  * The payload of this command is a NTCAN_BAUDRATE_X structure according to
 224  * esd electronics gmbh, NTCAN Application Developers Manual, 6.2.15 NTCAN_BAUDRATE_X
 225  * https://esd.eu/fileadmin/esd/docs/manuals/NTCAN_Part1_Function_API_Manual_en_56.pdf
 226  */
 227 struct esd_usb_3_set_baudrate_msg_x {
 228         u8 len; /* total message length in 32bit words */
 229         u8 cmd;
 230         u8 net;
 231         u8 rsvd;        /*reserved */
 232         /* Payload ... */
 233         __le16 mode;    /* mode word, see ESD_USB_3_BAUDRATE_MODE_xxx */
 234         __le16 flags;   /* control flags, see ESD_USB_3_BAUDRATE_FLAG_xxx */
 235         struct esd_usb_3_tdc_cfg tdc;   /* TDC configuration */
 236         struct esd_usb_3_baudrate_cfg nom;      /* nominal bit rate */
 237         struct esd_usb_3_baudrate_cfg data;     /* data bit rate */
 238 };
 239
 240 /* Main message type used between library and application */
 241 union __packed esd_usb_msg {
 242         struct esd_usb_header_msg hdr;
 243         struct esd_usb_version_msg version;
 244         struct esd_usb_version_reply_msg version_reply;
 245         struct esd_usb_rx_msg rx;
 246         struct esd_usb_tx_msg tx;
 247         struct esd_usb_tx_done_msg txdone;
 248         struct esd_usb_set_baudrate_msg setbaud;
 249         struct esd_usb_3_set_baudrate_msg_x setbaud_x;
 250         struct esd_usb_id_filter_msg filter;
 251 };
 252
 253 static struct usb_device_id esd_usb_table[] = {
 254         {USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSB2_PRODUCT_ID)},
 255         {USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSBM_PRODUCT_ID)},
 256         {USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSB3_PRODUCT_ID)},
 257         {}
 258 };
 259 MODULE_DEVICE_TABLE(usb, esd_usb_table);
 260
 261 struct esd_usb_net_priv;
 262
 263 struct esd_tx_urb_context {
 264         struct esd_usb_net_priv *priv;
 265         u32 echo_index;
 266 };
 267
 268 struct esd_usb {
 269         struct usb_device *udev;
 270         struct esd_usb_net_priv *nets[ESD_USB_MAX_NETS];
 271
 272         struct usb_anchor rx_submitted;
 273
 274         int net_count;
 275         u32 version;
 276         int rxinitdone;
 277         void *rxbuf[ESD_USB_MAX_RX_URBS];
 278         dma_addr_t rxbuf_dma[ESD_USB_MAX_RX_URBS];
 279 };
 280
 281 struct esd_usb_net_priv {
 282         struct can_priv can; /* must be the first member */
 283
 284         atomic_t active_tx_jobs;
 285         struct usb_anchor tx_submitted;
 286         struct esd_tx_urb_context tx_contexts[ESD_USB_MAX_TX_URBS];
 287
 288         struct esd_usb *usb;
 289         struct net_device *netdev;
 290         int index;
 291         u8 old_state;
 292         struct can_berr_counter bec;
 293 };
 294
 295 static void esd_usb_rx_event(struct esd_usb_net_priv *priv,
 296                              union esd_usb_msg *msg)
 297 {
 298         struct net_device_stats *stats = &priv->netdev->stats;
 299         struct can_frame *cf;
 300         struct sk_buff *skb;
 301         u32 id = le32_to_cpu(msg->rx.id) & ESD_USB_IDMASK;
 302
 303         if (id == ESD_USB_EV_CAN_ERROR_EXT) {
 304                 u8 state = msg->rx.ev_can_err_ext.status;
 305                 u8 ecc = msg->rx.ev_can_err_ext.ecc;
 306
 307                 priv->bec.rxerr = msg->rx.ev_can_err_ext.rec;
 308                 priv->bec.txerr = msg->rx.ev_can_err_ext.tec;
 309
 310                 netdev_dbg(priv->netdev,
 311                            "CAN_ERR_EV_EXT: dlc=%#02x state=%02x ecc=%02x rec=%02x tec=%02x\n",
 312                            msg->rx.dlc, state, ecc,
 313                            priv->bec.rxerr, priv->bec.txerr);
 314
 315                 /* if berr-reporting is off, only pass through on state change ... */
 316                 if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) &&
 317                     state == priv->old_state)
 318                         return;
 319
 320                 skb = alloc_can_err_skb(priv->netdev, &cf);
 321                 if (!skb)
 322                         stats->rx_dropped++;
 323
 324                 if (state != priv->old_state) {
 325                         enum can_state tx_state, rx_state;
 326                         enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
 327
 328                         priv->old_state = state;
 329
 330                         switch (state & ESD_USB_BUSSTATE_MASK) {
 331                         case ESD_USB_BUSSTATE_BUSOFF:
 332                                 new_state = CAN_STATE_BUS_OFF;
 333                                 can_bus_off(priv->netdev);
 334                                 break;
 335                         case ESD_USB_BUSSTATE_WARN:
 336                                 new_state = CAN_STATE_ERROR_WARNING;
 337                                 break;
 338                         case ESD_USB_BUSSTATE_ERRPASSIVE:
 339                                 new_state = CAN_STATE_ERROR_PASSIVE;
 340                                 break;
 341                         default:
 342                                 new_state = CAN_STATE_ERROR_ACTIVE;
 343                                 priv->bec.txerr = 0;
 344                                 priv->bec.rxerr = 0;
 345                                 break;
 346                         }
 347
 348                         if (new_state != priv->can.state) {
 349                                 tx_state = (priv->bec.txerr >= priv->bec.rxerr) ? new_state : 0;
 350                                 rx_state = (priv->bec.txerr <= priv->bec.rxerr) ? new_state : 0;
 351                                 can_change_state(priv->netdev, cf,
 352                                                  tx_state, rx_state);
 353                         }
 354                 } else if (skb) {
 355                         priv->can.can_stats.bus_error++;
 356                         stats->rx_errors++;
 357
 358                         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 359
 360                         switch (ecc & ESD_USB_SJA1000_ECC_MASK) {
 361                         case ESD_USB_SJA1000_ECC_BIT:
 362                                 cf->data[2] |= CAN_ERR_PROT_BIT;
 363                                 break;
 364                         case ESD_USB_SJA1000_ECC_FORM:
 365                                 cf->data[2] |= CAN_ERR_PROT_FORM;
 366                                 break;
 367                         case ESD_USB_SJA1000_ECC_STUFF:
 368                                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 369                                 break;
 370                         default:
 371                                 break;
 372                         }
 373
 374                         /* Error occurred during transmission? */
 375                         if (!(ecc & ESD_USB_SJA1000_ECC_DIR))
 376                                 cf->data[2] |= CAN_ERR_PROT_TX;
 377
 378                         /* Bit stream position in CAN frame as the error was detected */
 379                         cf->data[3] = ecc & ESD_USB_SJA1000_ECC_SEG;
 380                 }
 381
 382                 if (skb) {
 383                         cf->can_id |= CAN_ERR_CNT;
 384                         cf->data[6] = priv->bec.txerr;
 385                         cf->data[7] = priv->bec.rxerr;
 386
 387                         netif_rx(skb);
 388                 }
 389         }
 390 }
 391
 392 static void esd_usb_rx_can_msg(struct esd_usb_net_priv *priv,
 393                                union esd_usb_msg *msg)
 394 {
 395         struct net_device_stats *stats = &priv->netdev->stats;
 396         struct can_frame *cf;
 397         struct canfd_frame *cfd;
 398         struct sk_buff *skb;
 399         u32 id;
 400         u8 len;
 401
 402         if (!netif_device_present(priv->netdev))
 403                 return;
 404
 405         id = le32_to_cpu(msg->rx.id);
 406
 407         if (id & ESD_USB_EVENT) {
 408                 esd_usb_rx_event(priv, msg);
 409         } else {
 410                 if (msg->rx.dlc & ESD_USB_FD) {
 411                         skb = alloc_canfd_skb(priv->netdev, &cfd);
 412                 } else {
 413                         skb = alloc_can_skb(priv->netdev, &cf);
 414                         cfd = (struct canfd_frame *)cf;
 415                 }
 416
 417                 if (skb == NULL) {
 418                         stats->rx_dropped++;
 419                         return;
 420                 }
 421
 422                 cfd->can_id = id & ESD_USB_IDMASK;
 423
 424                 if (msg->rx.dlc & ESD_USB_FD) {
 425                         /* masking by 0x0F is already done within can_fd_dlc2len() */
 426                         cfd->len = can_fd_dlc2len(msg->rx.dlc);
 427                         len = cfd->len;
 428                         if ((msg->rx.dlc & ESD_USB_NO_BRS) == 0)
 429                                 cfd->flags |= CANFD_BRS;
 430                         if (msg->rx.dlc & ESD_USB_ESI)
 431                                 cfd->flags |= CANFD_ESI;
 432                 } else {
 433                         can_frame_set_cc_len(cf, msg->rx.dlc & ~ESD_USB_RTR, priv->can.ctrlmode);
 434                         len = cf->len;
 435                         if (msg->rx.dlc & ESD_USB_RTR) {
 436                                 cf->can_id |= CAN_RTR_FLAG;
 437                                 len = 0;
 438                         }
 439                 }
 440
 441                 if (id & ESD_USB_EXTID)
 442                         cfd->can_id |= CAN_EFF_FLAG;
 443
 444                 memcpy(cfd->data, msg->rx.data_fd, len);
 445                 stats->rx_bytes += len;
 446                 stats->rx_packets++;
 447
 448                 netif_rx(skb);
 449         }
 450 }
 451
 452 static void esd_usb_tx_done_msg(struct esd_usb_net_priv *priv,
 453                                 union esd_usb_msg *msg)
 454 {
 455         struct net_device_stats *stats = &priv->netdev->stats;
 456         struct net_device *netdev = priv->netdev;
 457         struct esd_tx_urb_context *context;
 458
 459         if (!netif_device_present(netdev))
 460                 return;
 461
 462         context = &priv->tx_contexts[msg->txdone.hnd & (ESD_USB_MAX_TX_URBS - 1)];
 463
 464         if (!msg->txdone.status) {
 465                 stats->tx_packets++;
 466                 stats->tx_bytes += can_get_echo_skb(netdev, context->echo_index,
 467                                                     NULL);
 468         } else {
 469                 stats->tx_errors++;
 470                 can_free_echo_skb(netdev, context->echo_index, NULL);
 471         }
 472
 473         /* Release context */
 474         context->echo_index = ESD_USB_MAX_TX_URBS;
 475         atomic_dec(&priv->active_tx_jobs);
 476
 477         netif_wake_queue(netdev);
 478 }
 479
 480 static void esd_usb_read_bulk_callback(struct urb *urb)
 481 {
 482         struct esd_usb *dev = urb->context;
 483         int retval;
 484         int pos = 0;
 485         int i;
 486
 487         switch (urb->status) {
 488         case 0: /* success */
 489                 break;
 490
 491         case -ENOENT:
 492         case -EPIPE:
 493         case -EPROTO:
 494         case -ESHUTDOWN:
 495                 return;
 496
 497         default:
 498                 dev_info(dev->udev->dev.parent,
 499                          "Rx URB aborted (%d)\n", urb->status);
 500                 goto resubmit_urb;
 501         }
 502
 503         while (pos < urb->actual_length) {
 504                 union esd_usb_msg *msg;
 505
 506                 msg = (union esd_usb_msg *)(urb->transfer_buffer + pos);
 507
 508                 switch (msg->hdr.cmd) {
 509                 case ESD_USB_CMD_CAN_RX:
 510                         if (msg->rx.net >= dev->net_count) {
 511                                 dev_err(dev->udev->dev.parent, "format error\n");
 512                                 break;
 513                         }
 514
 515                         esd_usb_rx_can_msg(dev->nets[msg->rx.net], msg);
 516                         break;
 517
 518                 case ESD_USB_CMD_CAN_TX:
 519                         if (msg->txdone.net >= dev->net_count) {
 520                                 dev_err(dev->udev->dev.parent, "format error\n");
 521                                 break;
 522                         }
 523
 524                         esd_usb_tx_done_msg(dev->nets[msg->txdone.net],
 525                                             msg);
 526                         break;
 527                 }
 528
 529                 pos += msg->hdr.len * sizeof(u32); /* convert to # of bytes */
 530
 531                 if (pos > urb->actual_length) {
 532                         dev_err(dev->udev->dev.parent, "format error\n");
 533                         break;
 534                 }
 535         }
 536
 537 resubmit_urb:
 538         usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 539                           urb->transfer_buffer, ESD_USB_RX_BUFFER_SIZE,
 540                           esd_usb_read_bulk_callback, dev);
 541
 542         retval = usb_submit_urb(urb, GFP_ATOMIC);
 543         if (retval == -ENODEV) {
 544                 for (i = 0; i < dev->net_count; i++) {
 545                         if (dev->nets[i])
 546                                 netif_device_detach(dev->nets[i]->netdev);
 547                 }
 548         } else if (retval) {
 549                 dev_err(dev->udev->dev.parent,
 550                         "failed resubmitting read bulk urb: %d\n", retval);
 551         }
 552 }
 553
 554 /* callback for bulk IN urb */
 555 static void esd_usb_write_bulk_callback(struct urb *urb)
 556 {
 557         struct esd_tx_urb_context *context = urb->context;
 558         struct esd_usb_net_priv *priv;
 559         struct net_device *netdev;
 560         size_t size = sizeof(union esd_usb_msg);
 561
 562         WARN_ON(!context);
 563
 564         priv = context->priv;
 565         netdev = priv->netdev;
 566
 567         /* free up our allocated buffer */
 568         usb_free_coherent(urb->dev, size,
 569                           urb->transfer_buffer, urb->transfer_dma);
 570
 571         if (!netif_device_present(netdev))
 572                 return;
 573
 574         if (urb->status)
 575                 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
 576
 577         netif_trans_update(netdev);
 578 }
 579
 580 static ssize_t firmware_show(struct device *d,
 581                              struct device_attribute *attr, char *buf)
 582 {
 583         struct usb_interface *intf = to_usb_interface(d);
 584         struct esd_usb *dev = usb_get_intfdata(intf);
 585
 586         return sprintf(buf, "%d.%d.%d\n",
 587                        (dev->version >> 12) & 0xf,
 588                        (dev->version >> 8) & 0xf,
 589                        dev->version & 0xff);
 590 }
 591 static DEVICE_ATTR_RO(firmware);
 592
 593 static ssize_t hardware_show(struct device *d,
 594                              struct device_attribute *attr, char *buf)
 595 {
 596         struct usb_interface *intf = to_usb_interface(d);
 597         struct esd_usb *dev = usb_get_intfdata(intf);
 598
 599         return sprintf(buf, "%d.%d.%d\n",
 600                        (dev->version >> 28) & 0xf,
 601                        (dev->version >> 24) & 0xf,
 602                        (dev->version >> 16) & 0xff);
 603 }
 604 static DEVICE_ATTR_RO(hardware);
 605
 606 static ssize_t nets_show(struct device *d,
 607                          struct device_attribute *attr, char *buf)
 608 {
 609         struct usb_interface *intf = to_usb_interface(d);
 610         struct esd_usb *dev = usb_get_intfdata(intf);
 611
 612         return sprintf(buf, "%d", dev->net_count);
 613 }
 614 static DEVICE_ATTR_RO(nets);
 615
 616 static int esd_usb_send_msg(struct esd_usb *dev, union esd_usb_msg *msg)
 617 {
 618         int actual_length;
 619
 620         return usb_bulk_msg(dev->udev,
 621                             usb_sndbulkpipe(dev->udev, 2),
 622                             msg,
 623                             msg->hdr.len * sizeof(u32), /* convert to # of bytes */
 624                             &actual_length,
 625                             1000);
 626 }
 627
 628 static int esd_usb_wait_msg(struct esd_usb *dev,
 629                             union esd_usb_msg *msg)
 630 {
 631         int actual_length;
 632
 633         return usb_bulk_msg(dev->udev,
 634                             usb_rcvbulkpipe(dev->udev, 1),
 635                             msg,
 636                             sizeof(*msg),
 637                             &actual_length,
 638                             1000);
 639 }
 640
 641 static int esd_usb_setup_rx_urbs(struct esd_usb *dev)
 642 {
 643         int i, err = 0;
 644
 645         if (dev->rxinitdone)
 646                 return 0;
 647
 648         for (i = 0; i < ESD_USB_MAX_RX_URBS; i++) {
 649                 struct urb *urb = NULL;
 650                 u8 *buf = NULL;
 651                 dma_addr_t buf_dma;
 652
 653                 /* create a URB, and a buffer for it */
 654                 urb = usb_alloc_urb(0, GFP_KERNEL);
 655                 if (!urb) {
 656                         err = -ENOMEM;
 657                         break;
 658                 }
 659
 660                 buf = usb_alloc_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, GFP_KERNEL,
 661                                          &buf_dma);
 662                 if (!buf) {
 663                         dev_warn(dev->udev->dev.parent,
 664                                  "No memory left for USB buffer\n");
 665                         err = -ENOMEM;
 666                         goto freeurb;
 667                 }
 668
 669                 urb->transfer_dma = buf_dma;
 670
 671                 usb_fill_bulk_urb(urb, dev->udev,
 672                                   usb_rcvbulkpipe(dev->udev, 1),
 673                                   buf, ESD_USB_RX_BUFFER_SIZE,
 674                                   esd_usb_read_bulk_callback, dev);
 675                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 676                 usb_anchor_urb(urb, &dev->rx_submitted);
 677
 678                 err = usb_submit_urb(urb, GFP_KERNEL);
 679                 if (err) {
 680                         usb_unanchor_urb(urb);
 681                         usb_free_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE, buf,
 682                                           urb->transfer_dma);
 683                         goto freeurb;
 684                 }
 685
 686                 dev->rxbuf[i] = buf;
 687                 dev->rxbuf_dma[i] = buf_dma;
 688
 689 freeurb:
 690                 /* Drop reference, USB core will take care of freeing it */
 691                 usb_free_urb(urb);
 692                 if (err)
 693                         break;
 694         }
 695
 696         /* Did we submit any URBs */
 697         if (i == 0) {
 698                 dev_err(dev->udev->dev.parent, "couldn't setup read URBs\n");
 699                 return err;
 700         }
 701
 702         /* Warn if we've couldn't transmit all the URBs */
 703         if (i < ESD_USB_MAX_RX_URBS) {
 704                 dev_warn(dev->udev->dev.parent,
 705                          "rx performance may be slow\n");
 706         }
 707
 708         dev->rxinitdone = 1;
 709         return 0;
 710 }
 711
 712 /* Start interface */
 713 static int esd_usb_start(struct esd_usb_net_priv *priv)
 714 {
 715         struct esd_usb *dev = priv->usb;
 716         struct net_device *netdev = priv->netdev;
 717         union esd_usb_msg *msg;
 718         int err, i;
 719
 720         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 721         if (!msg) {
 722                 err = -ENOMEM;
 723                 goto out;
 724         }
 725
 726         /* Enable all IDs
 727          * The IDADD message takes up to 64 32 bit bitmasks (2048 bits).
 728          * Each bit represents one 11 bit CAN identifier. A set bit
 729          * enables reception of the corresponding CAN identifier. A cleared
 730          * bit disabled this identifier. An additional bitmask value
 731          * following the CAN 2.0A bits is used to enable reception of
 732          * extended CAN frames. Only the LSB of this final mask is checked
 733          * for the complete 29 bit ID range. The IDADD message also allows
 734          * filter configuration for an ID subset. In this case you can add
 735          * the number of the starting bitmask (0..64) to the filter.option
 736          * field followed by only some bitmasks.
 737          */
 738         msg->hdr.cmd = ESD_USB_CMD_IDADD;
 739         msg->hdr.len = sizeof(struct esd_usb_id_filter_msg) / sizeof(u32); /* # of 32bit words */
 740         msg->filter.net = priv->index;
 741         msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */
 742         for (i = 0; i < ESD_USB_MAX_ID_SEGMENT; i++)
 743                 msg->filter.mask[i] = cpu_to_le32(GENMASK(31, 0));
 744         /* enable 29bit extended IDs */
 745         msg->filter.mask[ESD_USB_MAX_ID_SEGMENT] = cpu_to_le32(BIT(0));
 746
 747         err = esd_usb_send_msg(dev, msg);
 748         if (err)
 749                 goto out;
 750
 751         err = esd_usb_setup_rx_urbs(dev);
 752         if (err)
 753                 goto out;
 754
 755         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 756
 757 out:
 758         if (err == -ENODEV)
 759                 netif_device_detach(netdev);
 760         if (err)
 761                 netdev_err(netdev, "couldn't start device: %d\n", err);
 762
 763         kfree(msg);
 764         return err;
 765 }
 766
 767 static void unlink_all_urbs(struct esd_usb *dev)
 768 {
 769         struct esd_usb_net_priv *priv;
 770         int i, j;
 771
 772         usb_kill_anchored_urbs(&dev->rx_submitted);
 773
 774         for (i = 0; i < ESD_USB_MAX_RX_URBS; ++i)
 775                 usb_free_coherent(dev->udev, ESD_USB_RX_BUFFER_SIZE,
 776                                   dev->rxbuf[i], dev->rxbuf_dma[i]);
 777
 778         for (i = 0; i < dev->net_count; i++) {
 779                 priv = dev->nets[i];
 780                 if (priv) {
 781                         usb_kill_anchored_urbs(&priv->tx_submitted);
 782                         atomic_set(&priv->active_tx_jobs, 0);
 783
 784                         for (j = 0; j < ESD_USB_MAX_TX_URBS; j++)
 785                                 priv->tx_contexts[j].echo_index = ESD_USB_MAX_TX_URBS;
 786                 }
 787         }
 788 }
 789
 790 static int esd_usb_open(struct net_device *netdev)
 791 {
 792         struct esd_usb_net_priv *priv = netdev_priv(netdev);
 793         int err;
 794
 795         /* common open */
 796         err = open_candev(netdev);
 797         if (err)
 798                 return err;
 799
 800         /* finally start device */
 801         err = esd_usb_start(priv);
 802         if (err) {
 803                 netdev_warn(netdev, "couldn't start device: %d\n", err);
 804                 close_candev(netdev);
 805                 return err;
 806         }
 807
 808         netif_start_queue(netdev);
 809
 810         return 0;
 811 }
 812
 813 static netdev_tx_t esd_usb_start_xmit(struct sk_buff *skb,
 814                                       struct net_device *netdev)
 815 {
 816         struct esd_usb_net_priv *priv = netdev_priv(netdev);
 817         struct esd_usb *dev = priv->usb;
 818         struct esd_tx_urb_context *context = NULL;
 819         struct net_device_stats *stats = &netdev->stats;
 820         struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
 821         union esd_usb_msg *msg;
 822         struct urb *urb;
 823         u8 *buf;
 824         int i, err;
 825         int ret = NETDEV_TX_OK;
 826         size_t size = sizeof(union esd_usb_msg);
 827
 828         if (can_dev_dropped_skb(netdev, skb))
 829                 return NETDEV_TX_OK;
 830
 831         /* create a URB, and a buffer for it, and copy the data to the URB */
 832         urb = usb_alloc_urb(0, GFP_ATOMIC);
 833         if (!urb) {
 834                 stats->tx_dropped++;
 835                 dev_kfree_skb(skb);
 836                 goto nourbmem;
 837         }
 838
 839         buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC,
 840                                  &urb->transfer_dma);
 841         if (!buf) {
 842                 netdev_err(netdev, "No memory left for USB buffer\n");
 843                 stats->tx_dropped++;
 844                 dev_kfree_skb(skb);
 845                 goto nobufmem;
 846         }
 847
 848         msg = (union esd_usb_msg *)buf;
 849
 850         /* minimal length as # of 32bit words */
 851         msg->hdr.len = offsetof(struct esd_usb_tx_msg, data) / sizeof(u32);
 852         msg->hdr.cmd = ESD_USB_CMD_CAN_TX;
 853         msg->tx.net = priv->index;
 854
 855         if (can_is_canfd_skb(skb)) {
 856                 msg->tx.dlc = can_fd_len2dlc(cfd->len);
 857                 msg->tx.dlc |= ESD_USB_FD;
 858
 859                 if ((cfd->flags & CANFD_BRS) == 0)
 860                         msg->tx.dlc |= ESD_USB_NO_BRS;
 861         } else {
 862                 msg->tx.dlc = can_get_cc_dlc((struct can_frame *)cfd, priv->can.ctrlmode);
 863
 864                 if (cfd->can_id & CAN_RTR_FLAG)
 865                         msg->tx.dlc |= ESD_USB_RTR;
 866         }
 867
 868         msg->tx.id = cpu_to_le32(cfd->can_id & CAN_ERR_MASK);
 869
 870         if (cfd->can_id & CAN_EFF_FLAG)
 871                 msg->tx.id |= cpu_to_le32(ESD_USB_EXTID);
 872
 873         memcpy(msg->tx.data_fd, cfd->data, cfd->len);
 874
 875         /* round up, then divide by 4 to add the payload length as # of 32bit words */
 876         msg->hdr.len += DIV_ROUND_UP(cfd->len, sizeof(u32));
 877
 878         for (i = 0; i < ESD_USB_MAX_TX_URBS; i++) {
 879                 if (priv->tx_contexts[i].echo_index == ESD_USB_MAX_TX_URBS) {
 880                         context = &priv->tx_contexts[i];
 881                         break;
 882                 }
 883         }
 884
 885         /* This may never happen */
 886         if (!context) {
 887                 netdev_warn(netdev, "couldn't find free context\n");
 888                 ret = NETDEV_TX_BUSY;
 889                 goto releasebuf;
 890         }
 891
 892         context->priv = priv;
 893         context->echo_index = i;
 894
 895         /* hnd must not be 0 - MSB is stripped in txdone handling */
 896         msg->tx.hnd = BIT(31) | i; /* returned in TX done message */
 897
 898         usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf,
 899                           msg->hdr.len * sizeof(u32), /* convert to # of bytes */
 900                           esd_usb_write_bulk_callback, context);
 901
 902         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 903
 904         usb_anchor_urb(urb, &priv->tx_submitted);
 905
 906         can_put_echo_skb(skb, netdev, context->echo_index, 0);
 907
 908         atomic_inc(&priv->active_tx_jobs);
 909
 910         /* Slow down tx path */
 911         if (atomic_read(&priv->active_tx_jobs) >= ESD_USB_MAX_TX_URBS)
 912                 netif_stop_queue(netdev);
 913
 914         err = usb_submit_urb(urb, GFP_ATOMIC);
 915         if (err) {
 916                 can_free_echo_skb(netdev, context->echo_index, NULL);
 917
 918                 atomic_dec(&priv->active_tx_jobs);
 919                 usb_unanchor_urb(urb);
 920
 921                 stats->tx_dropped++;
 922
 923                 if (err == -ENODEV)
 924                         netif_device_detach(netdev);
 925                 else
 926                         netdev_warn(netdev, "failed tx_urb %d\n", err);
 927
 928                 goto releasebuf;
 929         }
 930
 931         netif_trans_update(netdev);
 932
 933         /* Release our reference to this URB, the USB core will eventually free
 934          * it entirely.
 935          */
 936         usb_free_urb(urb);
 937
 938         return NETDEV_TX_OK;
 939
 940 releasebuf:
 941         usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);
 942
 943 nobufmem:
 944         usb_free_urb(urb);
 945
 946 nourbmem:
 947         return ret;
 948 }
 949
 950 static int esd_usb_close(struct net_device *netdev)
 951 {
 952         struct esd_usb_net_priv *priv = netdev_priv(netdev);
 953         union esd_usb_msg *msg;
 954         int i;
 955
 956         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 957         if (!msg)
 958                 return -ENOMEM;
 959
 960         /* Disable all IDs (see esd_usb_start()) */
 961         msg->hdr.cmd = ESD_USB_CMD_IDADD;
 962         msg->hdr.len = sizeof(struct esd_usb_id_filter_msg) / sizeof(u32);/* # of 32bit words */
 963         msg->filter.net = priv->index;
 964         msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */
 965         for (i = 0; i <= ESD_USB_MAX_ID_SEGMENT; i++)
 966                 msg->filter.mask[i] = 0;
 967         if (esd_usb_send_msg(priv->usb, msg) < 0)
 968                 netdev_err(netdev, "sending idadd message failed\n");
 969
 970         /* set CAN controller to reset mode */
 971         msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */
 972         msg->hdr.cmd = ESD_USB_CMD_SETBAUD;
 973         msg->setbaud.net = priv->index;
 974         msg->setbaud.rsvd = 0;
 975         msg->setbaud.baud = cpu_to_le32(ESD_USB_NO_BAUDRATE);
 976         if (esd_usb_send_msg(priv->usb, msg) < 0)
 977                 netdev_err(netdev, "sending setbaud message failed\n");
 978
 979         priv->can.state = CAN_STATE_STOPPED;
 980
 981         netif_stop_queue(netdev);
 982
 983         close_candev(netdev);
 984
 985         kfree(msg);
 986
 987         return 0;
 988 }
 989
 990 static const struct net_device_ops esd_usb_netdev_ops = {
 991         .ndo_open = esd_usb_open,
 992         .ndo_stop = esd_usb_close,
 993         .ndo_start_xmit = esd_usb_start_xmit,
 994         .ndo_change_mtu = can_change_mtu,
 995 };
 996
 997 static const struct ethtool_ops esd_usb_ethtool_ops = {
 998         .get_ts_info = ethtool_op_get_ts_info,
 999 };
1000
1001 static const struct can_bittiming_const esd_usb_2_bittiming_const = {
1002         .name = "esd_usb_2",
1003         .tseg1_min = 1,
1004         .tseg1_max = 16,
1005         .tseg2_min = 1,
1006         .tseg2_max = 8,
1007         .sjw_max = 4,
1008         .brp_min = 1,
1009         .brp_max = 1024,
1010         .brp_inc = 1,
1011 };
1012
1013 static int esd_usb_2_set_bittiming(struct net_device *netdev)
1014 {
1015         const struct can_bittiming_const *btc = &esd_usb_2_bittiming_const;
1016         struct esd_usb_net_priv *priv = netdev_priv(netdev);
1017         struct can_bittiming *bt = &priv->can.bittiming;
1018         union esd_usb_msg *msg;
1019         int err;
1020         u32 canbtr;
1021         int sjw_shift;
1022
1023         canbtr = ESD_USB_UBR;
1024         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1025                 canbtr |= ESD_USB_LOM;
1026
1027         canbtr |= (bt->brp - 1) & (btc->brp_max - 1);
1028
1029         if (le16_to_cpu(priv->usb->udev->descriptor.idProduct) ==
1030             ESD_USB_CANUSBM_PRODUCT_ID)
1031                 sjw_shift = ESD_USB_M_SJW_SHIFT;
1032         else
1033                 sjw_shift = ESD_USB_2_SJW_SHIFT;
1034
1035         canbtr |= ((bt->sjw - 1) & (btc->sjw_max - 1))
1036                 << sjw_shift;
1037         canbtr |= ((bt->prop_seg + bt->phase_seg1 - 1)
1038                    & (btc->tseg1_max - 1))
1039                 << ESD_USB_2_TSEG1_SHIFT;
1040         canbtr |= ((bt->phase_seg2 - 1) & (btc->tseg2_max - 1))
1041                 << ESD_USB_2_TSEG2_SHIFT;
1042         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1043                 canbtr |= ESD_USB_TRIPLE_SAMPLES;
1044
1045         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1046         if (!msg)
1047                 return -ENOMEM;
1048
1049         msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */
1050         msg->hdr.cmd = ESD_USB_CMD_SETBAUD;
1051         msg->setbaud.net = priv->index;
1052         msg->setbaud.rsvd = 0;
1053         msg->setbaud.baud = cpu_to_le32(canbtr);
1054
1055         netdev_dbg(netdev, "setting BTR=%#x\n", canbtr);
1056
1057         err = esd_usb_send_msg(priv->usb, msg);
1058
1059         kfree(msg);
1060         return err;
1061 }
1062
1063 /* Nominal bittiming constants, see
1064  * Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022
1065  * 48.6.8 MCAN Nominal Bit Timing and Prescaler Register
1066  */
1067 static const struct can_bittiming_const esd_usb_3_nom_bittiming_const = {
1068         .name = "esd_usb_3",
1069         .tseg1_min = 2,
1070         .tseg1_max = 256,
1071         .tseg2_min = 2,
1072         .tseg2_max = 128,
1073         .sjw_max = 128,
1074         .brp_min = 1,
1075         .brp_max = 512,
1076         .brp_inc = 1,
1077 };
1078
1079 /* Data bittiming constants, see
1080  * Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022
1081  * 48.6.4 MCAN Data Bit Timing and Prescaler Register
1082  */
1083 static const struct can_bittiming_const esd_usb_3_data_bittiming_const = {
1084         .name = "esd_usb_3",
1085         .tseg1_min = 2,
1086         .tseg1_max = 32,
1087         .tseg2_min = 1,
1088         .tseg2_max = 16,
1089         .sjw_max = 8,
1090         .brp_min = 1,
1091         .brp_max = 32,
1092         .brp_inc = 1,
1093 };
1094
1095 static int esd_usb_3_set_bittiming(struct net_device *netdev)
1096 {
1097         const struct can_bittiming_const *nom_btc = &esd_usb_3_nom_bittiming_const;
1098         const struct can_bittiming_const *data_btc = &esd_usb_3_data_bittiming_const;
1099         struct esd_usb_net_priv *priv = netdev_priv(netdev);
1100         struct can_bittiming *nom_bt = &priv->can.bittiming;
1101         struct can_bittiming *data_bt = &priv->can.data_bittiming;
1102         struct esd_usb_3_set_baudrate_msg_x *baud_x;
1103         union esd_usb_msg *msg;
1104         u16 flags = 0;
1105         int err;
1106
1107         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1108         if (!msg)
1109                 return -ENOMEM;
1110
1111         baud_x = &msg->setbaud_x;
1112
1113         /* Canonical is the most reasonable mode for SocketCAN on CAN-USB/3 ... */
1114         baud_x->mode = cpu_to_le16(ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL);
1115
1116         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1117                 flags |= ESD_USB_3_BAUDRATE_FLAG_LOM;
1118
1119         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1120                 flags |= ESD_USB_3_BAUDRATE_FLAG_TRS;
1121
1122         baud_x->nom.brp = cpu_to_le16(nom_bt->brp & (nom_btc->brp_max - 1));
1123         baud_x->nom.sjw = cpu_to_le16(nom_bt->sjw & (nom_btc->sjw_max - 1));
1124         baud_x->nom.tseg1 = cpu_to_le16((nom_bt->prop_seg + nom_bt->phase_seg1)
1125                                         & (nom_btc->tseg1_max - 1));
1126         baud_x->nom.tseg2 = cpu_to_le16(nom_bt->phase_seg2 & (nom_btc->tseg2_max - 1));
1127
1128         if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1129                 baud_x->data.brp = cpu_to_le16(data_bt->brp & (data_btc->brp_max - 1));
1130                 baud_x->data.sjw = cpu_to_le16(data_bt->sjw & (data_btc->sjw_max - 1));
1131                 baud_x->data.tseg1 = cpu_to_le16((data_bt->prop_seg + data_bt->phase_seg1)
1132                                                  & (data_btc->tseg1_max - 1));
1133                 baud_x->data.tseg2 = cpu_to_le16(data_bt->phase_seg2 & (data_btc->tseg2_max - 1));
1134                 flags |= ESD_USB_3_BAUDRATE_FLAG_FD;
1135         }
1136
1137         /* Currently this driver only supports the automatic TDC mode */
1138         baud_x->tdc.tdc_mode = ESD_USB_3_TDC_MODE_AUTO;
1139         baud_x->tdc.ssp_offset = 0;
1140         baud_x->tdc.ssp_shift = 0;
1141         baud_x->tdc.tdc_filter = 0;
1142
1143         baud_x->flags = cpu_to_le16(flags);
1144         baud_x->net = priv->index;
1145         baud_x->rsvd = 0;
1146
1147         /* set len as # of 32bit words */
1148         msg->hdr.len = sizeof(struct esd_usb_3_set_baudrate_msg_x) / sizeof(u32);
1149         msg->hdr.cmd = ESD_USB_CMD_SETBAUD;
1150
1151         netdev_dbg(netdev,
1152                    "ctrlmode=%#x/%#x, esd-net=%u, esd-mode=%#x, esd-flags=%#x\n",
1153                    priv->can.ctrlmode, priv->can.ctrlmode_supported,
1154                    priv->index, le16_to_cpu(baud_x->mode), flags);
1155
1156         err = esd_usb_send_msg(priv->usb, msg);
1157
1158         kfree(msg);
1159         return err;
1160 }
1161
1162 static int esd_usb_get_berr_counter(const struct net_device *netdev,
1163                                     struct can_berr_counter *bec)
1164 {
1165         struct esd_usb_net_priv *priv = netdev_priv(netdev);
1166
1167         bec->txerr = priv->bec.txerr;
1168         bec->rxerr = priv->bec.rxerr;
1169
1170         return 0;
1171 }
1172
1173 static int esd_usb_set_mode(struct net_device *netdev, enum can_mode mode)
1174 {
1175         switch (mode) {
1176         case CAN_MODE_START:
1177                 netif_wake_queue(netdev);
1178                 break;
1179
1180         default:
1181                 return -EOPNOTSUPP;
1182         }
1183
1184         return 0;
1185 }
1186
1187 static int esd_usb_probe_one_net(struct usb_interface *intf, int index)
1188 {
1189         struct esd_usb *dev = usb_get_intfdata(intf);
1190         struct net_device *netdev;
1191         struct esd_usb_net_priv *priv;
1192         int err = 0;
1193         int i;
1194
1195         netdev = alloc_candev(sizeof(*priv), ESD_USB_MAX_TX_URBS);
1196         if (!netdev) {
1197                 dev_err(&intf->dev, "couldn't alloc candev\n");
1198                 err = -ENOMEM;
1199                 goto done;
1200         }
1201
1202         priv = netdev_priv(netdev);
1203
1204         init_usb_anchor(&priv->tx_submitted);
1205         atomic_set(&priv->active_tx_jobs, 0);
1206
1207         for (i = 0; i < ESD_USB_MAX_TX_URBS; i++)
1208                 priv->tx_contexts[i].echo_index = ESD_USB_MAX_TX_URBS;
1209
1210         priv->usb = dev;
1211         priv->netdev = netdev;
1212         priv->index = index;
1213
1214         priv->can.state = CAN_STATE_STOPPED;
1215         priv->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY |
1216                 CAN_CTRLMODE_CC_LEN8_DLC |
1217                 CAN_CTRLMODE_BERR_REPORTING;
1218
1219         switch (le16_to_cpu(dev->udev->descriptor.idProduct)) {
1220         case ESD_USB_CANUSB3_PRODUCT_ID:
1221                 priv->can.clock.freq = ESD_USB_3_CAN_CLOCK;
1222                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1223                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD;
1224                 priv->can.bittiming_const = &esd_usb_3_nom_bittiming_const;
1225                 priv->can.data_bittiming_const = &esd_usb_3_data_bittiming_const;
1226                 priv->can.do_set_bittiming = esd_usb_3_set_bittiming;
1227                 priv->can.do_set_data_bittiming = esd_usb_3_set_bittiming;
1228                 break;
1229
1230         case ESD_USB_CANUSBM_PRODUCT_ID:
1231                 priv->can.clock.freq = ESD_USB_M_CAN_CLOCK;
1232                 priv->can.bittiming_const = &esd_usb_2_bittiming_const;
1233                 priv->can.do_set_bittiming = esd_usb_2_set_bittiming;
1234                 break;
1235
1236         case ESD_USB_CANUSB2_PRODUCT_ID:
1237         default:
1238                 priv->can.clock.freq = ESD_USB_2_CAN_CLOCK;
1239                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1240                 priv->can.bittiming_const = &esd_usb_2_bittiming_const;
1241                 priv->can.do_set_bittiming = esd_usb_2_set_bittiming;
1242                 break;
1243         }
1244
1245         priv->can.do_set_mode = esd_usb_set_mode;
1246         priv->can.do_get_berr_counter = esd_usb_get_berr_counter;
1247
1248         netdev->flags |= IFF_ECHO; /* we support local echo */
1249
1250         netdev->netdev_ops = &esd_usb_netdev_ops;
1251         netdev->ethtool_ops = &esd_usb_ethtool_ops;
1252
1253         SET_NETDEV_DEV(netdev, &intf->dev);
1254         netdev->dev_id = index;
1255
1256         err = register_candev(netdev);
1257         if (err) {
1258                 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
1259                 free_candev(netdev);
1260                 err = -ENOMEM;
1261                 goto done;
1262         }
1263
1264         dev->nets[index] = priv;
1265         netdev_info(netdev, "device %s registered\n", netdev->name);
1266
1267 done:
1268         return err;
1269 }
1270
1271 /* probe function for new USB devices
1272  *
1273  * check version information and number of available
1274  * CAN interfaces
1275  */
1276 static int esd_usb_probe(struct usb_interface *intf,
1277                          const struct usb_device_id *id)
1278 {
1279         struct esd_usb *dev;
1280         union esd_usb_msg *msg;
1281         int i, err;
1282
1283         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1284         if (!dev) {
1285                 err = -ENOMEM;
1286                 goto done;
1287         }
1288
1289         dev->udev = interface_to_usbdev(intf);
1290
1291         init_usb_anchor(&dev->rx_submitted);
1292
1293         usb_set_intfdata(intf, dev);
1294
1295         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1296         if (!msg) {
1297                 err = -ENOMEM;
1298                 goto free_msg;
1299         }
1300
1301         /* query number of CAN interfaces (nets) */
1302         msg->hdr.cmd = ESD_USB_CMD_VERSION;
1303         msg->hdr.len = sizeof(struct esd_usb_version_msg) / sizeof(u32); /* # of 32bit words */
1304         msg->version.rsvd = 0;
1305         msg->version.flags = 0;
1306         msg->version.drv_version = 0;
1307
1308         err = esd_usb_send_msg(dev, msg);
1309         if (err < 0) {
1310                 dev_err(&intf->dev, "sending version message failed\n");
1311                 goto free_msg;
1312         }
1313
1314         err = esd_usb_wait_msg(dev, msg);
1315         if (err < 0) {
1316                 dev_err(&intf->dev, "no version message answer\n");
1317                 goto free_msg;
1318         }
1319
1320         dev->net_count = (int)msg->version_reply.nets;
1321         dev->version = le32_to_cpu(msg->version_reply.version);
1322
1323         if (device_create_file(&intf->dev, &dev_attr_firmware))
1324                 dev_err(&intf->dev,
1325                         "Couldn't create device file for firmware\n");
1326
1327         if (device_create_file(&intf->dev, &dev_attr_hardware))
1328                 dev_err(&intf->dev,
1329                         "Couldn't create device file for hardware\n");
1330
1331         if (device_create_file(&intf->dev, &dev_attr_nets))
1332                 dev_err(&intf->dev,
1333                         "Couldn't create device file for nets\n");
1334
1335         /* do per device probing */
1336         for (i = 0; i < dev->net_count; i++)
1337                 esd_usb_probe_one_net(intf, i);
1338
1339 free_msg:
1340         kfree(msg);
1341         if (err)
1342                 kfree(dev);
1343 done:
1344         return err;
1345 }
1346
1347 /* called by the usb core when the device is removed from the system */
1348 static void esd_usb_disconnect(struct usb_interface *intf)
1349 {
1350         struct esd_usb *dev = usb_get_intfdata(intf);
1351         struct net_device *netdev;
1352         int i;
1353
1354         device_remove_file(&intf->dev, &dev_attr_firmware);
1355         device_remove_file(&intf->dev, &dev_attr_hardware);
1356         device_remove_file(&intf->dev, &dev_attr_nets);
1357
1358         usb_set_intfdata(intf, NULL);
1359
1360         if (dev) {
1361                 for (i = 0; i < dev->net_count; i++) {
1362                         if (dev->nets[i]) {
1363                                 netdev = dev->nets[i]->netdev;
1364                                 unregister_netdev(netdev);
1365                                 free_candev(netdev);
1366                         }
1367                 }
1368                 unlink_all_urbs(dev);
1369                 kfree(dev);
1370         }
1371 }
1372
1373 /* usb specific object needed to register this driver with the usb subsystem */
1374 static struct usb_driver esd_usb_driver = {
1375         .name = KBUILD_MODNAME,
1376         .probe = esd_usb_probe,
1377         .disconnect = esd_usb_disconnect,
1378         .id_table = esd_usb_table,
1379 };
1380
1381 module_usb_driver(esd_usb_driver);