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