1 // SPDX-License-Identifier: GPL-2.0-only
2 /* CAN driver for Geschwister Schneider USB/CAN devices
3 * and bytewerk.org candleLight USB CAN interfaces.
4 *
5 * Copyright (C) 2013-2016 Geschwister Schneider Technologie-,
6 * Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
7 * Copyright (C) 2016 Hubert Denkmair
8 *
9 * Many thanks to all socketcan devs!
10 */
11
12 #include <linux/bitfield.h>
13 #include <linux/clocksource.h>
14 #include <linux/ethtool.h>
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/netdevice.h>
18 #include <linux/signal.h>
19 #include <linux/timecounter.h>
20 #include <linux/units.h>
21 #include <linux/usb.h>
22 #include <linux/workqueue.h>
23
24 #include <linux/can.h>
25 #include <linux/can/dev.h>
26 #include <linux/can/error.h>
27
28 /* Device specific constants */
29 #define USB_GS_USB_1_VENDOR_ID 0x1d50
30 #define USB_GS_USB_1_PRODUCT_ID 0x606f
31
32 #define USB_CANDLELIGHT_VENDOR_ID 0x1209
33 #define USB_CANDLELIGHT_PRODUCT_ID 0x2323
34
35 #define USB_CES_CANEXT_FD_VENDOR_ID 0x1cd2
36 #define USB_CES_CANEXT_FD_PRODUCT_ID 0x606f
37
38 #define USB_ABE_CANDEBUGGER_FD_VENDOR_ID 0x16d0
39 #define USB_ABE_CANDEBUGGER_FD_PRODUCT_ID 0x10b8
40
41 #define GS_USB_ENDPOINT_IN 1
42 #define GS_USB_ENDPOINT_OUT 2
43
44 /* Timestamp 32 bit timer runs at 1 MHz (1 µs tick). Worker accounts
45 * for timer overflow (will be after ~71 minutes)
46 */
47 #define GS_USB_TIMESTAMP_TIMER_HZ (1 * HZ_PER_MHZ)
48 #define GS_USB_TIMESTAMP_WORK_DELAY_SEC 1800
49 static_assert(GS_USB_TIMESTAMP_WORK_DELAY_SEC <
50 CYCLECOUNTER_MASK(32) / GS_USB_TIMESTAMP_TIMER_HZ / 2);
51
52 /* Device specific constants */
53 enum gs_usb_breq {
54 GS_USB_BREQ_HOST_FORMAT = 0,
55 GS_USB_BREQ_BITTIMING,
56 GS_USB_BREQ_MODE,
57 GS_USB_BREQ_BERR,
58 GS_USB_BREQ_BT_CONST,
59 GS_USB_BREQ_DEVICE_CONFIG,
60 GS_USB_BREQ_TIMESTAMP,
61 GS_USB_BREQ_IDENTIFY,
62 GS_USB_BREQ_GET_USER_ID,
63 GS_USB_BREQ_QUIRK_CANTACT_PRO_DATA_BITTIMING = GS_USB_BREQ_GET_USER_ID,
64 GS_USB_BREQ_SET_USER_ID,
65 GS_USB_BREQ_DATA_BITTIMING,
66 GS_USB_BREQ_BT_CONST_EXT,
67 GS_USB_BREQ_SET_TERMINATION,
68 GS_USB_BREQ_GET_TERMINATION,
69 };
70
71 enum gs_can_mode {
72 /* reset a channel. turns it off */
73 GS_CAN_MODE_RESET = 0,
74 /* starts a channel */
75 GS_CAN_MODE_START
76 };
77
78 enum gs_can_state {
79 GS_CAN_STATE_ERROR_ACTIVE = 0,
80 GS_CAN_STATE_ERROR_WARNING,
81 GS_CAN_STATE_ERROR_PASSIVE,
82 GS_CAN_STATE_BUS_OFF,
83 GS_CAN_STATE_STOPPED,
84 GS_CAN_STATE_SLEEPING
85 };
86
87 enum gs_can_identify_mode {
88 GS_CAN_IDENTIFY_OFF = 0,
89 GS_CAN_IDENTIFY_ON
90 };
91
92 enum gs_can_termination_state {
93 GS_CAN_TERMINATION_STATE_OFF = 0,
94 GS_CAN_TERMINATION_STATE_ON
95 };
96
97 #define GS_USB_TERMINATION_DISABLED CAN_TERMINATION_DISABLED
98 #define GS_USB_TERMINATION_ENABLED 120
99
100 /* data types passed between host and device */
101
102 /* The firmware on the original USB2CAN by Geschwister Schneider
103 * Technologie Entwicklungs- und Vertriebs UG exchanges all data
104 * between the host and the device in host byte order. This is done
105 * with the struct gs_host_config::byte_order member, which is sent
106 * first to indicate the desired byte order.
107 *
108 * The widely used open source firmware candleLight doesn't support
109 * this feature and exchanges the data in little endian byte order.
110 */
111 struct gs_host_config {
112 __le32 byte_order;
113 } __packed;
114
115 struct gs_device_config {
116 u8 reserved1;
117 u8 reserved2;
118 u8 reserved3;
119 u8 icount;
120 __le32 sw_version;
121 __le32 hw_version;
122 } __packed;
123
124 #define GS_CAN_MODE_NORMAL 0
125 #define GS_CAN_MODE_LISTEN_ONLY BIT(0)
126 #define GS_CAN_MODE_LOOP_BACK BIT(1)
127 #define GS_CAN_MODE_TRIPLE_SAMPLE BIT(2)
128 #define GS_CAN_MODE_ONE_SHOT BIT(3)
129 #define GS_CAN_MODE_HW_TIMESTAMP BIT(4)
130 /* GS_CAN_FEATURE_IDENTIFY BIT(5) */
131 /* GS_CAN_FEATURE_USER_ID BIT(6) */
132 #define GS_CAN_MODE_PAD_PKTS_TO_MAX_PKT_SIZE BIT(7)
133 #define GS_CAN_MODE_FD BIT(8)
134 /* GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX BIT(9) */
135 /* GS_CAN_FEATURE_BT_CONST_EXT BIT(10) */
136 /* GS_CAN_FEATURE_TERMINATION BIT(11) */
137
138 struct gs_device_mode {
139 __le32 mode;
140 __le32 flags;
141 } __packed;
142
143 struct gs_device_state {
144 __le32 state;
145 __le32 rxerr;
146 __le32 txerr;
147 } __packed;
148
149 struct gs_device_bittiming {
150 __le32 prop_seg;
151 __le32 phase_seg1;
152 __le32 phase_seg2;
153 __le32 sjw;
154 __le32 brp;
155 } __packed;
156
157 struct gs_identify_mode {
158 __le32 mode;
159 } __packed;
160
161 struct gs_device_termination_state {
162 __le32 state;
163 } __packed;
164
165 #define GS_CAN_FEATURE_LISTEN_ONLY BIT(0)
166 #define GS_CAN_FEATURE_LOOP_BACK BIT(1)
167 #define GS_CAN_FEATURE_TRIPLE_SAMPLE BIT(2)
168 #define GS_CAN_FEATURE_ONE_SHOT BIT(3)
169 #define GS_CAN_FEATURE_HW_TIMESTAMP BIT(4)
170 #define GS_CAN_FEATURE_IDENTIFY BIT(5)
171 #define GS_CAN_FEATURE_USER_ID BIT(6)
172 #define GS_CAN_FEATURE_PAD_PKTS_TO_MAX_PKT_SIZE BIT(7)
173 #define GS_CAN_FEATURE_FD BIT(8)
174 #define GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX BIT(9)
175 #define GS_CAN_FEATURE_BT_CONST_EXT BIT(10)
176 #define GS_CAN_FEATURE_TERMINATION BIT(11)
177 #define GS_CAN_FEATURE_MASK GENMASK(11, 0)
178
179 /* internal quirks - keep in GS_CAN_FEATURE space for now */
180
181 /* CANtact Pro original firmware:
182 * BREQ DATA_BITTIMING overlaps with GET_USER_ID
183 */
184 #define GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO BIT(31)
185
186 struct gs_device_bt_const {
187 __le32 feature;
188 __le32 fclk_can;
189 __le32 tseg1_min;
190 __le32 tseg1_max;
191 __le32 tseg2_min;
192 __le32 tseg2_max;
193 __le32 sjw_max;
194 __le32 brp_min;
195 __le32 brp_max;
196 __le32 brp_inc;
197 } __packed;
198
199 struct gs_device_bt_const_extended {
200 __le32 feature;
201 __le32 fclk_can;
202 __le32 tseg1_min;
203 __le32 tseg1_max;
204 __le32 tseg2_min;
205 __le32 tseg2_max;
206 __le32 sjw_max;
207 __le32 brp_min;
208 __le32 brp_max;
209 __le32 brp_inc;
210
211 __le32 dtseg1_min;
212 __le32 dtseg1_max;
213 __le32 dtseg2_min;
214 __le32 dtseg2_max;
215 __le32 dsjw_max;
216 __le32 dbrp_min;
217 __le32 dbrp_max;
218 __le32 dbrp_inc;
219 } __packed;
220
221 #define GS_CAN_FLAG_OVERFLOW BIT(0)
222 #define GS_CAN_FLAG_FD BIT(1)
223 #define GS_CAN_FLAG_BRS BIT(2)
224 #define GS_CAN_FLAG_ESI BIT(3)
225
226 struct classic_can {
227 u8 data[8];
228 } __packed;
229
230 struct classic_can_ts {
231 u8 data[8];
232 __le32 timestamp_us;
233 } __packed;
234
235 struct classic_can_quirk {
236 u8 data[8];
237 u8 quirk;
238 } __packed;
239
240 struct canfd {
241 u8 data[64];
242 } __packed;
243
244 struct canfd_ts {
245 u8 data[64];
246 __le32 timestamp_us;
247 } __packed;
248
249 struct canfd_quirk {
250 u8 data[64];
251 u8 quirk;
252 } __packed;
253
254 struct gs_host_frame {
255 u32 echo_id;
256 __le32 can_id;
257
258 u8 can_dlc;
259 u8 channel;
260 u8 flags;
261 u8 reserved;
262
263 union {
264 DECLARE_FLEX_ARRAY(struct classic_can, classic_can);
265 DECLARE_FLEX_ARRAY(struct classic_can_ts, classic_can_ts);
266 DECLARE_FLEX_ARRAY(struct classic_can_quirk, classic_can_quirk);
267 DECLARE_FLEX_ARRAY(struct canfd, canfd);
268 DECLARE_FLEX_ARRAY(struct canfd_ts, canfd_ts);
269 DECLARE_FLEX_ARRAY(struct canfd_quirk, canfd_quirk);
270 };
271 } __packed;
272 /* The GS USB devices make use of the same flags and masks as in
273 * linux/can.h and linux/can/error.h, and no additional mapping is necessary.
274 */
275
276 /* Only send a max of GS_MAX_TX_URBS frames per channel at a time. */
277 #define GS_MAX_TX_URBS 10
278 /* Only launch a max of GS_MAX_RX_URBS usb requests at a time. */
279 #define GS_MAX_RX_URBS 30
280 /* Maximum number of interfaces the driver supports per device.
281 * Current hardware only supports 3 interfaces. The future may vary.
282 */
283 #define GS_MAX_INTF 3
284
285 struct gs_tx_context {
286 struct gs_can *dev;
287 unsigned int echo_id;
288 };
289
290 struct gs_can {
291 struct can_priv can; /* must be the first member */
292
293 struct gs_usb *parent;
294
295 struct net_device *netdev;
296 struct usb_device *udev;
297 struct usb_interface *iface;
298
299 struct can_bittiming_const bt_const, data_bt_const;
300 unsigned int channel; /* channel number */
301
302 /* time counter for hardware timestamps */
303 struct cyclecounter cc;
304 struct timecounter tc;
305 spinlock_t tc_lock; /* spinlock to guard access tc->cycle_last */
306 struct delayed_work timestamp;
307
308 u32 feature;
309 unsigned int hf_size_tx;
310
311 /* This lock prevents a race condition between xmit and receive. */
312 spinlock_t tx_ctx_lock;
313 struct gs_tx_context tx_context[GS_MAX_TX_URBS];
314
315 struct usb_anchor tx_submitted;
316 atomic_t active_tx_urbs;
317 };
318
319 /* usb interface struct */
320 struct gs_usb {
321 struct gs_can *canch[GS_MAX_INTF];
322 struct usb_anchor rx_submitted;
323 struct usb_device *udev;
324 unsigned int hf_size_rx;
325 u8 active_channels;
326 };
327
328 /* 'allocate' a tx context.
329 * returns a valid tx context or NULL if there is no space.
330 */
gs_alloc_tx_context(struct gs_can * dev)331 static struct gs_tx_context *gs_alloc_tx_context(struct gs_can *dev)
332 {
333 int i = 0;
334 unsigned long flags;
335
336 spin_lock_irqsave(&dev->tx_ctx_lock, flags);
337
338 for (; i < GS_MAX_TX_URBS; i++) {
339 if (dev->tx_context[i].echo_id == GS_MAX_TX_URBS) {
340 dev->tx_context[i].echo_id = i;
341 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
342 return &dev->tx_context[i];
343 }
344 }
345
346 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
347 return NULL;
348 }
349
350 /* releases a tx context
351 */
gs_free_tx_context(struct gs_tx_context * txc)352 static void gs_free_tx_context(struct gs_tx_context *txc)
353 {
354 txc->echo_id = GS_MAX_TX_URBS;
355 }
356
357 /* Get a tx context by id.
358 */
gs_get_tx_context(struct gs_can * dev,unsigned int id)359 static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev,
360 unsigned int id)
361 {
362 unsigned long flags;
363
364 if (id < GS_MAX_TX_URBS) {
365 spin_lock_irqsave(&dev->tx_ctx_lock, flags);
366 if (dev->tx_context[id].echo_id == id) {
367 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
368 return &dev->tx_context[id];
369 }
370 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
371 }
372 return NULL;
373 }
374
gs_cmd_reset(struct gs_can * dev)375 static int gs_cmd_reset(struct gs_can *dev)
376 {
377 struct gs_device_mode dm = {
378 .mode = GS_CAN_MODE_RESET,
379 };
380
381 return usb_control_msg_send(interface_to_usbdev(dev->iface), 0,
382 GS_USB_BREQ_MODE,
383 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
384 dev->channel, 0, &dm, sizeof(dm), 1000,
385 GFP_KERNEL);
386 }
387
gs_usb_get_timestamp(const struct gs_can * dev,u32 * timestamp_p)388 static inline int gs_usb_get_timestamp(const struct gs_can *dev,
389 u32 *timestamp_p)
390 {
391 __le32 timestamp;
392 int rc;
393
394 rc = usb_control_msg_recv(interface_to_usbdev(dev->iface), 0,
395 GS_USB_BREQ_TIMESTAMP,
396 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
397 dev->channel, 0,
398 ×tamp, sizeof(timestamp),
399 USB_CTRL_GET_TIMEOUT,
400 GFP_KERNEL);
401 if (rc)
402 return rc;
403
404 *timestamp_p = le32_to_cpu(timestamp);
405
406 return 0;
407 }
408
gs_usb_timestamp_read(const struct cyclecounter * cc)409 static u64 gs_usb_timestamp_read(const struct cyclecounter *cc) __must_hold(&dev->tc_lock)
410 {
411 struct gs_can *dev = container_of(cc, struct gs_can, cc);
412 u32 timestamp = 0;
413 int err;
414
415 lockdep_assert_held(&dev->tc_lock);
416
417 /* drop lock for synchronous USB transfer */
418 spin_unlock_bh(&dev->tc_lock);
419 err = gs_usb_get_timestamp(dev, ×tamp);
420 spin_lock_bh(&dev->tc_lock);
421 if (err)
422 netdev_err(dev->netdev,
423 "Error %d while reading timestamp. HW timestamps may be inaccurate.",
424 err);
425
426 return timestamp;
427 }
428
gs_usb_timestamp_work(struct work_struct * work)429 static void gs_usb_timestamp_work(struct work_struct *work)
430 {
431 struct delayed_work *delayed_work = to_delayed_work(work);
432 struct gs_can *dev;
433
434 dev = container_of(delayed_work, struct gs_can, timestamp);
435 spin_lock_bh(&dev->tc_lock);
436 timecounter_read(&dev->tc);
437 spin_unlock_bh(&dev->tc_lock);
438
439 schedule_delayed_work(&dev->timestamp,
440 GS_USB_TIMESTAMP_WORK_DELAY_SEC * HZ);
441 }
442
gs_usb_skb_set_timestamp(struct gs_can * dev,struct sk_buff * skb,u32 timestamp)443 static void gs_usb_skb_set_timestamp(struct gs_can *dev,
444 struct sk_buff *skb, u32 timestamp)
445 {
446 struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
447 u64 ns;
448
449 spin_lock_bh(&dev->tc_lock);
450 ns = timecounter_cyc2time(&dev->tc, timestamp);
451 spin_unlock_bh(&dev->tc_lock);
452
453 hwtstamps->hwtstamp = ns_to_ktime(ns);
454 }
455
gs_usb_timestamp_init(struct gs_can * dev)456 static void gs_usb_timestamp_init(struct gs_can *dev)
457 {
458 struct cyclecounter *cc = &dev->cc;
459
460 cc->read = gs_usb_timestamp_read;
461 cc->mask = CYCLECOUNTER_MASK(32);
462 cc->shift = 32 - bits_per(NSEC_PER_SEC / GS_USB_TIMESTAMP_TIMER_HZ);
463 cc->mult = clocksource_hz2mult(GS_USB_TIMESTAMP_TIMER_HZ, cc->shift);
464
465 spin_lock_init(&dev->tc_lock);
466 spin_lock_bh(&dev->tc_lock);
467 timecounter_init(&dev->tc, &dev->cc, ktime_get_real_ns());
468 spin_unlock_bh(&dev->tc_lock);
469
470 INIT_DELAYED_WORK(&dev->timestamp, gs_usb_timestamp_work);
471 schedule_delayed_work(&dev->timestamp,
472 GS_USB_TIMESTAMP_WORK_DELAY_SEC * HZ);
473 }
474
gs_usb_timestamp_stop(struct gs_can * dev)475 static void gs_usb_timestamp_stop(struct gs_can *dev)
476 {
477 cancel_delayed_work_sync(&dev->timestamp);
478 }
479
gs_update_state(struct gs_can * dev,struct can_frame * cf)480 static void gs_update_state(struct gs_can *dev, struct can_frame *cf)
481 {
482 struct can_device_stats *can_stats = &dev->can.can_stats;
483
484 if (cf->can_id & CAN_ERR_RESTARTED) {
485 dev->can.state = CAN_STATE_ERROR_ACTIVE;
486 can_stats->restarts++;
487 } else if (cf->can_id & CAN_ERR_BUSOFF) {
488 dev->can.state = CAN_STATE_BUS_OFF;
489 can_stats->bus_off++;
490 } else if (cf->can_id & CAN_ERR_CRTL) {
491 if ((cf->data[1] & CAN_ERR_CRTL_TX_WARNING) ||
492 (cf->data[1] & CAN_ERR_CRTL_RX_WARNING)) {
493 dev->can.state = CAN_STATE_ERROR_WARNING;
494 can_stats->error_warning++;
495 } else if ((cf->data[1] & CAN_ERR_CRTL_TX_PASSIVE) ||
496 (cf->data[1] & CAN_ERR_CRTL_RX_PASSIVE)) {
497 dev->can.state = CAN_STATE_ERROR_PASSIVE;
498 can_stats->error_passive++;
499 } else {
500 dev->can.state = CAN_STATE_ERROR_ACTIVE;
501 }
502 }
503 }
504
gs_usb_set_timestamp(struct gs_can * dev,struct sk_buff * skb,const struct gs_host_frame * hf)505 static void gs_usb_set_timestamp(struct gs_can *dev, struct sk_buff *skb,
506 const struct gs_host_frame *hf)
507 {
508 u32 timestamp;
509
510 if (!(dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP))
511 return;
512
513 if (hf->flags & GS_CAN_FLAG_FD)
514 timestamp = le32_to_cpu(hf->canfd_ts->timestamp_us);
515 else
516 timestamp = le32_to_cpu(hf->classic_can_ts->timestamp_us);
517
518 gs_usb_skb_set_timestamp(dev, skb, timestamp);
519
520 return;
521 }
522
gs_usb_receive_bulk_callback(struct urb * urb)523 static void gs_usb_receive_bulk_callback(struct urb *urb)
524 {
525 struct gs_usb *usbcan = urb->context;
526 struct gs_can *dev;
527 struct net_device *netdev;
528 int rc;
529 struct net_device_stats *stats;
530 struct gs_host_frame *hf = urb->transfer_buffer;
531 struct gs_tx_context *txc;
532 struct can_frame *cf;
533 struct canfd_frame *cfd;
534 struct sk_buff *skb;
535
536 BUG_ON(!usbcan);
537
538 switch (urb->status) {
539 case 0: /* success */
540 break;
541 case -ENOENT:
542 case -ESHUTDOWN:
543 return;
544 default:
545 /* do not resubmit aborted urbs. eg: when device goes down */
546 return;
547 }
548
549 /* device reports out of range channel id */
550 if (hf->channel >= GS_MAX_INTF)
551 goto device_detach;
552
553 dev = usbcan->canch[hf->channel];
554
555 netdev = dev->netdev;
556 stats = &netdev->stats;
557
558 if (!netif_device_present(netdev))
559 return;
560
561 if (hf->echo_id == -1) { /* normal rx */
562 if (hf->flags & GS_CAN_FLAG_FD) {
563 skb = alloc_canfd_skb(dev->netdev, &cfd);
564 if (!skb)
565 return;
566
567 cfd->can_id = le32_to_cpu(hf->can_id);
568 cfd->len = can_fd_dlc2len(hf->can_dlc);
569 if (hf->flags & GS_CAN_FLAG_BRS)
570 cfd->flags |= CANFD_BRS;
571 if (hf->flags & GS_CAN_FLAG_ESI)
572 cfd->flags |= CANFD_ESI;
573
574 memcpy(cfd->data, hf->canfd->data, cfd->len);
575 } else {
576 skb = alloc_can_skb(dev->netdev, &cf);
577 if (!skb)
578 return;
579
580 cf->can_id = le32_to_cpu(hf->can_id);
581 can_frame_set_cc_len(cf, hf->can_dlc, dev->can.ctrlmode);
582
583 memcpy(cf->data, hf->classic_can->data, 8);
584
585 /* ERROR frames tell us information about the controller */
586 if (le32_to_cpu(hf->can_id) & CAN_ERR_FLAG)
587 gs_update_state(dev, cf);
588 }
589
590 gs_usb_set_timestamp(dev, skb, hf);
591
592 netdev->stats.rx_packets++;
593 netdev->stats.rx_bytes += hf->can_dlc;
594
595 netif_rx(skb);
596 } else { /* echo_id == hf->echo_id */
597 if (hf->echo_id >= GS_MAX_TX_URBS) {
598 netdev_err(netdev,
599 "Unexpected out of range echo id %u\n",
600 hf->echo_id);
601 goto resubmit_urb;
602 }
603
604 txc = gs_get_tx_context(dev, hf->echo_id);
605
606 /* bad devices send bad echo_ids. */
607 if (!txc) {
608 netdev_err(netdev,
609 "Unexpected unused echo id %u\n",
610 hf->echo_id);
611 goto resubmit_urb;
612 }
613
614 skb = dev->can.echo_skb[hf->echo_id];
615 gs_usb_set_timestamp(dev, skb, hf);
616
617 netdev->stats.tx_packets++;
618 netdev->stats.tx_bytes += can_get_echo_skb(netdev, hf->echo_id,
619 NULL);
620
621 gs_free_tx_context(txc);
622
623 atomic_dec(&dev->active_tx_urbs);
624
625 netif_wake_queue(netdev);
626 }
627
628 if (hf->flags & GS_CAN_FLAG_OVERFLOW) {
629 skb = alloc_can_err_skb(netdev, &cf);
630 if (!skb)
631 goto resubmit_urb;
632
633 cf->can_id |= CAN_ERR_CRTL;
634 cf->len = CAN_ERR_DLC;
635 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
636 stats->rx_over_errors++;
637 stats->rx_errors++;
638 netif_rx(skb);
639 }
640
641 resubmit_urb:
642 usb_fill_bulk_urb(urb, usbcan->udev,
643 usb_rcvbulkpipe(usbcan->udev, GS_USB_ENDPOINT_IN),
644 hf, dev->parent->hf_size_rx,
645 gs_usb_receive_bulk_callback, usbcan);
646
647 rc = usb_submit_urb(urb, GFP_ATOMIC);
648
649 /* USB failure take down all interfaces */
650 if (rc == -ENODEV) {
651 device_detach:
652 for (rc = 0; rc < GS_MAX_INTF; rc++) {
653 if (usbcan->canch[rc])
654 netif_device_detach(usbcan->canch[rc]->netdev);
655 }
656 }
657 }
658
gs_usb_set_bittiming(struct net_device * netdev)659 static int gs_usb_set_bittiming(struct net_device *netdev)
660 {
661 struct gs_can *dev = netdev_priv(netdev);
662 struct can_bittiming *bt = &dev->can.bittiming;
663 struct gs_device_bittiming dbt = {
664 .prop_seg = cpu_to_le32(bt->prop_seg),
665 .phase_seg1 = cpu_to_le32(bt->phase_seg1),
666 .phase_seg2 = cpu_to_le32(bt->phase_seg2),
667 .sjw = cpu_to_le32(bt->sjw),
668 .brp = cpu_to_le32(bt->brp),
669 };
670
671 /* request bit timings */
672 return usb_control_msg_send(interface_to_usbdev(dev->iface), 0,
673 GS_USB_BREQ_BITTIMING,
674 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
675 dev->channel, 0, &dbt, sizeof(dbt), 1000,
676 GFP_KERNEL);
677 }
678
gs_usb_set_data_bittiming(struct net_device * netdev)679 static int gs_usb_set_data_bittiming(struct net_device *netdev)
680 {
681 struct gs_can *dev = netdev_priv(netdev);
682 struct can_bittiming *bt = &dev->can.data_bittiming;
683 struct gs_device_bittiming dbt = {
684 .prop_seg = cpu_to_le32(bt->prop_seg),
685 .phase_seg1 = cpu_to_le32(bt->phase_seg1),
686 .phase_seg2 = cpu_to_le32(bt->phase_seg2),
687 .sjw = cpu_to_le32(bt->sjw),
688 .brp = cpu_to_le32(bt->brp),
689 };
690 u8 request = GS_USB_BREQ_DATA_BITTIMING;
691
692 if (dev->feature & GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO)
693 request = GS_USB_BREQ_QUIRK_CANTACT_PRO_DATA_BITTIMING;
694
695 /* request data bit timings */
696 return usb_control_msg_send(interface_to_usbdev(dev->iface), 0,
697 request,
698 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
699 dev->channel, 0, &dbt, sizeof(dbt), 1000,
700 GFP_KERNEL);
701 }
702
gs_usb_xmit_callback(struct urb * urb)703 static void gs_usb_xmit_callback(struct urb *urb)
704 {
705 struct gs_tx_context *txc = urb->context;
706 struct gs_can *dev = txc->dev;
707 struct net_device *netdev = dev->netdev;
708
709 if (urb->status)
710 netdev_info(netdev, "usb xmit fail %u\n", txc->echo_id);
711 }
712
gs_can_start_xmit(struct sk_buff * skb,struct net_device * netdev)713 static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,
714 struct net_device *netdev)
715 {
716 struct gs_can *dev = netdev_priv(netdev);
717 struct net_device_stats *stats = &dev->netdev->stats;
718 struct urb *urb;
719 struct gs_host_frame *hf;
720 struct can_frame *cf;
721 struct canfd_frame *cfd;
722 int rc;
723 unsigned int idx;
724 struct gs_tx_context *txc;
725
726 if (can_dev_dropped_skb(netdev, skb))
727 return NETDEV_TX_OK;
728
729 /* find an empty context to keep track of transmission */
730 txc = gs_alloc_tx_context(dev);
731 if (!txc)
732 return NETDEV_TX_BUSY;
733
734 /* create a URB, and a buffer for it */
735 urb = usb_alloc_urb(0, GFP_ATOMIC);
736 if (!urb)
737 goto nomem_urb;
738
739 hf = kmalloc(dev->hf_size_tx, GFP_ATOMIC);
740 if (!hf) {
741 netdev_err(netdev, "No memory left for USB buffer\n");
742 goto nomem_hf;
743 }
744
745 idx = txc->echo_id;
746
747 if (idx >= GS_MAX_TX_URBS) {
748 netdev_err(netdev, "Invalid tx context %u\n", idx);
749 goto badidx;
750 }
751
752 hf->echo_id = idx;
753 hf->channel = dev->channel;
754 hf->flags = 0;
755 hf->reserved = 0;
756
757 if (can_is_canfd_skb(skb)) {
758 cfd = (struct canfd_frame *)skb->data;
759
760 hf->can_id = cpu_to_le32(cfd->can_id);
761 hf->can_dlc = can_fd_len2dlc(cfd->len);
762 hf->flags |= GS_CAN_FLAG_FD;
763 if (cfd->flags & CANFD_BRS)
764 hf->flags |= GS_CAN_FLAG_BRS;
765 if (cfd->flags & CANFD_ESI)
766 hf->flags |= GS_CAN_FLAG_ESI;
767
768 memcpy(hf->canfd->data, cfd->data, cfd->len);
769 } else {
770 cf = (struct can_frame *)skb->data;
771
772 hf->can_id = cpu_to_le32(cf->can_id);
773 hf->can_dlc = can_get_cc_dlc(cf, dev->can.ctrlmode);
774
775 memcpy(hf->classic_can->data, cf->data, cf->len);
776 }
777
778 usb_fill_bulk_urb(urb, dev->udev,
779 usb_sndbulkpipe(dev->udev, GS_USB_ENDPOINT_OUT),
780 hf, dev->hf_size_tx,
781 gs_usb_xmit_callback, txc);
782
783 urb->transfer_flags |= URB_FREE_BUFFER;
784 usb_anchor_urb(urb, &dev->tx_submitted);
785
786 can_put_echo_skb(skb, netdev, idx, 0);
787
788 atomic_inc(&dev->active_tx_urbs);
789
790 rc = usb_submit_urb(urb, GFP_ATOMIC);
791 if (unlikely(rc)) { /* usb send failed */
792 atomic_dec(&dev->active_tx_urbs);
793
794 can_free_echo_skb(netdev, idx, NULL);
795 gs_free_tx_context(txc);
796
797 usb_unanchor_urb(urb);
798
799 if (rc == -ENODEV) {
800 netif_device_detach(netdev);
801 } else {
802 netdev_err(netdev, "usb_submit failed (err=%d)\n", rc);
803 stats->tx_dropped++;
804 }
805 } else {
806 /* Slow down tx path */
807 if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS)
808 netif_stop_queue(netdev);
809 }
810
811 /* let usb core take care of this urb */
812 usb_free_urb(urb);
813
814 return NETDEV_TX_OK;
815
816 badidx:
817 kfree(hf);
818 nomem_hf:
819 usb_free_urb(urb);
820
821 nomem_urb:
822 gs_free_tx_context(txc);
823 dev_kfree_skb(skb);
824 stats->tx_dropped++;
825 return NETDEV_TX_OK;
826 }
827
gs_can_open(struct net_device * netdev)828 static int gs_can_open(struct net_device *netdev)
829 {
830 struct gs_can *dev = netdev_priv(netdev);
831 struct gs_usb *parent = dev->parent;
832 struct gs_device_mode dm = {
833 .mode = cpu_to_le32(GS_CAN_MODE_START),
834 };
835 struct gs_host_frame *hf;
836 u32 ctrlmode;
837 u32 flags = 0;
838 int rc, i;
839
840 rc = open_candev(netdev);
841 if (rc)
842 return rc;
843
844 ctrlmode = dev->can.ctrlmode;
845 if (ctrlmode & CAN_CTRLMODE_FD) {
846 flags |= GS_CAN_MODE_FD;
847
848 if (dev->feature & GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX)
849 dev->hf_size_tx = struct_size(hf, canfd_quirk, 1);
850 else
851 dev->hf_size_tx = struct_size(hf, canfd, 1);
852 } else {
853 if (dev->feature & GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX)
854 dev->hf_size_tx = struct_size(hf, classic_can_quirk, 1);
855 else
856 dev->hf_size_tx = struct_size(hf, classic_can, 1);
857 }
858
859 if (!parent->active_channels) {
860 for (i = 0; i < GS_MAX_RX_URBS; i++) {
861 struct urb *urb;
862 u8 *buf;
863
864 /* alloc rx urb */
865 urb = usb_alloc_urb(0, GFP_KERNEL);
866 if (!urb)
867 return -ENOMEM;
868
869 /* alloc rx buffer */
870 buf = kmalloc(dev->parent->hf_size_rx,
871 GFP_KERNEL);
872 if (!buf) {
873 netdev_err(netdev,
874 "No memory left for USB buffer\n");
875 usb_free_urb(urb);
876 return -ENOMEM;
877 }
878
879 /* fill, anchor, and submit rx urb */
880 usb_fill_bulk_urb(urb,
881 dev->udev,
882 usb_rcvbulkpipe(dev->udev,
883 GS_USB_ENDPOINT_IN),
884 buf,
885 dev->parent->hf_size_rx,
886 gs_usb_receive_bulk_callback, parent);
887 urb->transfer_flags |= URB_FREE_BUFFER;
888
889 usb_anchor_urb(urb, &parent->rx_submitted);
890
891 rc = usb_submit_urb(urb, GFP_KERNEL);
892 if (rc) {
893 if (rc == -ENODEV)
894 netif_device_detach(dev->netdev);
895
896 netdev_err(netdev,
897 "usb_submit failed (err=%d)\n", rc);
898
899 usb_unanchor_urb(urb);
900 usb_free_urb(urb);
901 break;
902 }
903
904 /* Drop reference,
905 * USB core will take care of freeing it
906 */
907 usb_free_urb(urb);
908 }
909 }
910
911 /* flags */
912 if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
913 flags |= GS_CAN_MODE_LOOP_BACK;
914 else if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
915 flags |= GS_CAN_MODE_LISTEN_ONLY;
916
917 /* Controller is not allowed to retry TX
918 * this mode is unavailable on atmels uc3c hardware
919 */
920 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
921 flags |= GS_CAN_MODE_ONE_SHOT;
922
923 if (ctrlmode & CAN_CTRLMODE_3_SAMPLES)
924 flags |= GS_CAN_MODE_TRIPLE_SAMPLE;
925
926 /* if hardware supports timestamps, enable it */
927 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
928 flags |= GS_CAN_MODE_HW_TIMESTAMP;
929
930 /* start polling timestamp */
931 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
932 gs_usb_timestamp_init(dev);
933
934 /* finally start device */
935 dev->can.state = CAN_STATE_ERROR_ACTIVE;
936 dm.flags = cpu_to_le32(flags);
937 rc = usb_control_msg_send(interface_to_usbdev(dev->iface), 0,
938 GS_USB_BREQ_MODE,
939 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
940 dev->channel, 0, &dm, sizeof(dm), 1000,
941 GFP_KERNEL);
942 if (rc) {
943 netdev_err(netdev, "Couldn't start device (err=%d)\n", rc);
944 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
945 gs_usb_timestamp_stop(dev);
946 dev->can.state = CAN_STATE_STOPPED;
947 return rc;
948 }
949
950 parent->active_channels++;
951 if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
952 netif_start_queue(netdev);
953
954 return 0;
955 }
956
gs_can_close(struct net_device * netdev)957 static int gs_can_close(struct net_device *netdev)
958 {
959 int rc;
960 struct gs_can *dev = netdev_priv(netdev);
961 struct gs_usb *parent = dev->parent;
962
963 netif_stop_queue(netdev);
964
965 /* stop polling timestamp */
966 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
967 gs_usb_timestamp_stop(dev);
968
969 /* Stop polling */
970 parent->active_channels--;
971 if (!parent->active_channels) {
972 usb_kill_anchored_urbs(&parent->rx_submitted);
973 }
974
975 /* Stop sending URBs */
976 usb_kill_anchored_urbs(&dev->tx_submitted);
977 atomic_set(&dev->active_tx_urbs, 0);
978
979 /* reset the device */
980 rc = gs_cmd_reset(dev);
981 if (rc < 0)
982 netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc);
983
984 /* reset tx contexts */
985 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
986 dev->tx_context[rc].dev = dev;
987 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
988 }
989
990 /* close the netdev */
991 close_candev(netdev);
992
993 return 0;
994 }
995
gs_can_eth_ioctl(struct net_device * netdev,struct ifreq * ifr,int cmd)996 static int gs_can_eth_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
997 {
998 const struct gs_can *dev = netdev_priv(netdev);
999
1000 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
1001 return can_eth_ioctl_hwts(netdev, ifr, cmd);
1002
1003 return -EOPNOTSUPP;
1004 }
1005
1006 static const struct net_device_ops gs_usb_netdev_ops = {
1007 .ndo_open = gs_can_open,
1008 .ndo_stop = gs_can_close,
1009 .ndo_start_xmit = gs_can_start_xmit,
1010 .ndo_change_mtu = can_change_mtu,
1011 .ndo_eth_ioctl = gs_can_eth_ioctl,
1012 };
1013
gs_usb_set_identify(struct net_device * netdev,bool do_identify)1014 static int gs_usb_set_identify(struct net_device *netdev, bool do_identify)
1015 {
1016 struct gs_can *dev = netdev_priv(netdev);
1017 struct gs_identify_mode imode;
1018
1019 if (do_identify)
1020 imode.mode = cpu_to_le32(GS_CAN_IDENTIFY_ON);
1021 else
1022 imode.mode = cpu_to_le32(GS_CAN_IDENTIFY_OFF);
1023
1024 return usb_control_msg_send(interface_to_usbdev(dev->iface), 0,
1025 GS_USB_BREQ_IDENTIFY,
1026 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1027 dev->channel, 0, &imode, sizeof(imode), 100,
1028 GFP_KERNEL);
1029 }
1030
1031 /* blink LED's for finding the this interface */
gs_usb_set_phys_id(struct net_device * netdev,enum ethtool_phys_id_state state)1032 static int gs_usb_set_phys_id(struct net_device *netdev,
1033 enum ethtool_phys_id_state state)
1034 {
1035 const struct gs_can *dev = netdev_priv(netdev);
1036 int rc = 0;
1037
1038 if (!(dev->feature & GS_CAN_FEATURE_IDENTIFY))
1039 return -EOPNOTSUPP;
1040
1041 switch (state) {
1042 case ETHTOOL_ID_ACTIVE:
1043 rc = gs_usb_set_identify(netdev, GS_CAN_IDENTIFY_ON);
1044 break;
1045 case ETHTOOL_ID_INACTIVE:
1046 rc = gs_usb_set_identify(netdev, GS_CAN_IDENTIFY_OFF);
1047 break;
1048 default:
1049 break;
1050 }
1051
1052 return rc;
1053 }
1054
gs_usb_get_ts_info(struct net_device * netdev,struct ethtool_ts_info * info)1055 static int gs_usb_get_ts_info(struct net_device *netdev,
1056 struct ethtool_ts_info *info)
1057 {
1058 struct gs_can *dev = netdev_priv(netdev);
1059
1060 /* report if device supports HW timestamps */
1061 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
1062 return can_ethtool_op_get_ts_info_hwts(netdev, info);
1063
1064 return ethtool_op_get_ts_info(netdev, info);
1065 }
1066
1067 static const struct ethtool_ops gs_usb_ethtool_ops = {
1068 .set_phys_id = gs_usb_set_phys_id,
1069 .get_ts_info = gs_usb_get_ts_info,
1070 };
1071
gs_usb_get_termination(struct net_device * netdev,u16 * term)1072 static int gs_usb_get_termination(struct net_device *netdev, u16 *term)
1073 {
1074 struct gs_can *dev = netdev_priv(netdev);
1075 struct gs_device_termination_state term_state;
1076 int rc;
1077
1078 rc = usb_control_msg_recv(interface_to_usbdev(dev->iface), 0,
1079 GS_USB_BREQ_GET_TERMINATION,
1080 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1081 dev->channel, 0,
1082 &term_state, sizeof(term_state), 1000,
1083 GFP_KERNEL);
1084 if (rc)
1085 return rc;
1086
1087 if (term_state.state == cpu_to_le32(GS_CAN_TERMINATION_STATE_ON))
1088 *term = GS_USB_TERMINATION_ENABLED;
1089 else
1090 *term = GS_USB_TERMINATION_DISABLED;
1091
1092 return 0;
1093 }
1094
gs_usb_set_termination(struct net_device * netdev,u16 term)1095 static int gs_usb_set_termination(struct net_device *netdev, u16 term)
1096 {
1097 struct gs_can *dev = netdev_priv(netdev);
1098 struct gs_device_termination_state term_state;
1099
1100 if (term == GS_USB_TERMINATION_ENABLED)
1101 term_state.state = cpu_to_le32(GS_CAN_TERMINATION_STATE_ON);
1102 else
1103 term_state.state = cpu_to_le32(GS_CAN_TERMINATION_STATE_OFF);
1104
1105 return usb_control_msg_send(interface_to_usbdev(dev->iface), 0,
1106 GS_USB_BREQ_SET_TERMINATION,
1107 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1108 dev->channel, 0,
1109 &term_state, sizeof(term_state), 1000,
1110 GFP_KERNEL);
1111 }
1112
1113 static const u16 gs_usb_termination_const[] = {
1114 GS_USB_TERMINATION_DISABLED,
1115 GS_USB_TERMINATION_ENABLED
1116 };
1117
gs_make_candev(unsigned int channel,struct usb_interface * intf,struct gs_device_config * dconf)1118 static struct gs_can *gs_make_candev(unsigned int channel,
1119 struct usb_interface *intf,
1120 struct gs_device_config *dconf)
1121 {
1122 struct gs_can *dev;
1123 struct net_device *netdev;
1124 int rc;
1125 struct gs_device_bt_const_extended bt_const_extended;
1126 struct gs_device_bt_const bt_const;
1127 u32 feature;
1128
1129 /* fetch bit timing constants */
1130 rc = usb_control_msg_recv(interface_to_usbdev(intf), 0,
1131 GS_USB_BREQ_BT_CONST,
1132 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1133 channel, 0, &bt_const, sizeof(bt_const), 1000,
1134 GFP_KERNEL);
1135
1136 if (rc) {
1137 dev_err(&intf->dev,
1138 "Couldn't get bit timing const for channel %d (%pe)\n",
1139 channel, ERR_PTR(rc));
1140 return ERR_PTR(rc);
1141 }
1142
1143 /* create netdev */
1144 netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS);
1145 if (!netdev) {
1146 dev_err(&intf->dev, "Couldn't allocate candev\n");
1147 return ERR_PTR(-ENOMEM);
1148 }
1149
1150 dev = netdev_priv(netdev);
1151
1152 netdev->netdev_ops = &gs_usb_netdev_ops;
1153 netdev->ethtool_ops = &gs_usb_ethtool_ops;
1154
1155 netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */
1156
1157 /* dev setup */
1158 strcpy(dev->bt_const.name, KBUILD_MODNAME);
1159 dev->bt_const.tseg1_min = le32_to_cpu(bt_const.tseg1_min);
1160 dev->bt_const.tseg1_max = le32_to_cpu(bt_const.tseg1_max);
1161 dev->bt_const.tseg2_min = le32_to_cpu(bt_const.tseg2_min);
1162 dev->bt_const.tseg2_max = le32_to_cpu(bt_const.tseg2_max);
1163 dev->bt_const.sjw_max = le32_to_cpu(bt_const.sjw_max);
1164 dev->bt_const.brp_min = le32_to_cpu(bt_const.brp_min);
1165 dev->bt_const.brp_max = le32_to_cpu(bt_const.brp_max);
1166 dev->bt_const.brp_inc = le32_to_cpu(bt_const.brp_inc);
1167
1168 dev->udev = interface_to_usbdev(intf);
1169 dev->iface = intf;
1170 dev->netdev = netdev;
1171 dev->channel = channel;
1172
1173 init_usb_anchor(&dev->tx_submitted);
1174 atomic_set(&dev->active_tx_urbs, 0);
1175 spin_lock_init(&dev->tx_ctx_lock);
1176 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
1177 dev->tx_context[rc].dev = dev;
1178 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
1179 }
1180
1181 /* can setup */
1182 dev->can.state = CAN_STATE_STOPPED;
1183 dev->can.clock.freq = le32_to_cpu(bt_const.fclk_can);
1184 dev->can.bittiming_const = &dev->bt_const;
1185 dev->can.do_set_bittiming = gs_usb_set_bittiming;
1186
1187 dev->can.ctrlmode_supported = CAN_CTRLMODE_CC_LEN8_DLC;
1188
1189 feature = le32_to_cpu(bt_const.feature);
1190 dev->feature = FIELD_GET(GS_CAN_FEATURE_MASK, feature);
1191 if (feature & GS_CAN_FEATURE_LISTEN_ONLY)
1192 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
1193
1194 if (feature & GS_CAN_FEATURE_LOOP_BACK)
1195 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK;
1196
1197 if (feature & GS_CAN_FEATURE_TRIPLE_SAMPLE)
1198 dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1199
1200 if (feature & GS_CAN_FEATURE_ONE_SHOT)
1201 dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
1202
1203 if (feature & GS_CAN_FEATURE_FD) {
1204 dev->can.ctrlmode_supported |= CAN_CTRLMODE_FD;
1205 /* The data bit timing will be overwritten, if
1206 * GS_CAN_FEATURE_BT_CONST_EXT is set.
1207 */
1208 dev->can.data_bittiming_const = &dev->bt_const;
1209 dev->can.do_set_data_bittiming = gs_usb_set_data_bittiming;
1210 }
1211
1212 if (feature & GS_CAN_FEATURE_TERMINATION) {
1213 rc = gs_usb_get_termination(netdev, &dev->can.termination);
1214 if (rc) {
1215 dev->feature &= ~GS_CAN_FEATURE_TERMINATION;
1216
1217 dev_info(&intf->dev,
1218 "Disabling termination support for channel %d (%pe)\n",
1219 channel, ERR_PTR(rc));
1220 } else {
1221 dev->can.termination_const = gs_usb_termination_const;
1222 dev->can.termination_const_cnt = ARRAY_SIZE(gs_usb_termination_const);
1223 dev->can.do_set_termination = gs_usb_set_termination;
1224 }
1225 }
1226
1227 /* The CANtact Pro from LinkLayer Labs is based on the
1228 * LPC54616 µC, which is affected by the NXP LPC USB transfer
1229 * erratum. However, the current firmware (version 2) doesn't
1230 * set the GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX bit. Set the
1231 * feature GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX to workaround
1232 * this issue.
1233 *
1234 * For the GS_USB_BREQ_DATA_BITTIMING USB control message the
1235 * CANtact Pro firmware uses a request value, which is already
1236 * used by the candleLight firmware for a different purpose
1237 * (GS_USB_BREQ_GET_USER_ID). Set the feature
1238 * GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO to workaround this
1239 * issue.
1240 */
1241 if (dev->udev->descriptor.idVendor == cpu_to_le16(USB_GS_USB_1_VENDOR_ID) &&
1242 dev->udev->descriptor.idProduct == cpu_to_le16(USB_GS_USB_1_PRODUCT_ID) &&
1243 dev->udev->manufacturer && dev->udev->product &&
1244 !strcmp(dev->udev->manufacturer, "LinkLayer Labs") &&
1245 !strcmp(dev->udev->product, "CANtact Pro") &&
1246 (le32_to_cpu(dconf->sw_version) <= 2))
1247 dev->feature |= GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX |
1248 GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO;
1249
1250 /* GS_CAN_FEATURE_IDENTIFY is only supported for sw_version > 1 */
1251 if (!(le32_to_cpu(dconf->sw_version) > 1 &&
1252 feature & GS_CAN_FEATURE_IDENTIFY))
1253 dev->feature &= ~GS_CAN_FEATURE_IDENTIFY;
1254
1255 /* fetch extended bit timing constants if device has feature
1256 * GS_CAN_FEATURE_FD and GS_CAN_FEATURE_BT_CONST_EXT
1257 */
1258 if (feature & GS_CAN_FEATURE_FD &&
1259 feature & GS_CAN_FEATURE_BT_CONST_EXT) {
1260 rc = usb_control_msg_recv(interface_to_usbdev(intf), 0,
1261 GS_USB_BREQ_BT_CONST_EXT,
1262 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1263 channel, 0, &bt_const_extended,
1264 sizeof(bt_const_extended),
1265 1000, GFP_KERNEL);
1266 if (rc) {
1267 dev_err(&intf->dev,
1268 "Couldn't get extended bit timing const for channel %d (%pe)\n",
1269 channel, ERR_PTR(rc));
1270 goto out_free_candev;
1271 }
1272
1273 strcpy(dev->data_bt_const.name, KBUILD_MODNAME);
1274 dev->data_bt_const.tseg1_min = le32_to_cpu(bt_const_extended.dtseg1_min);
1275 dev->data_bt_const.tseg1_max = le32_to_cpu(bt_const_extended.dtseg1_max);
1276 dev->data_bt_const.tseg2_min = le32_to_cpu(bt_const_extended.dtseg2_min);
1277 dev->data_bt_const.tseg2_max = le32_to_cpu(bt_const_extended.dtseg2_max);
1278 dev->data_bt_const.sjw_max = le32_to_cpu(bt_const_extended.dsjw_max);
1279 dev->data_bt_const.brp_min = le32_to_cpu(bt_const_extended.dbrp_min);
1280 dev->data_bt_const.brp_max = le32_to_cpu(bt_const_extended.dbrp_max);
1281 dev->data_bt_const.brp_inc = le32_to_cpu(bt_const_extended.dbrp_inc);
1282
1283 dev->can.data_bittiming_const = &dev->data_bt_const;
1284 }
1285
1286 SET_NETDEV_DEV(netdev, &intf->dev);
1287
1288 rc = register_candev(dev->netdev);
1289 if (rc) {
1290 dev_err(&intf->dev,
1291 "Couldn't register candev for channel %d (%pe)\n",
1292 channel, ERR_PTR(rc));
1293 goto out_free_candev;
1294 }
1295
1296 return dev;
1297
1298 out_free_candev:
1299 free_candev(dev->netdev);
1300 return ERR_PTR(rc);
1301 }
1302
gs_destroy_candev(struct gs_can * dev)1303 static void gs_destroy_candev(struct gs_can *dev)
1304 {
1305 unregister_candev(dev->netdev);
1306 usb_kill_anchored_urbs(&dev->tx_submitted);
1307 free_candev(dev->netdev);
1308 }
1309
gs_usb_probe(struct usb_interface * intf,const struct usb_device_id * id)1310 static int gs_usb_probe(struct usb_interface *intf,
1311 const struct usb_device_id *id)
1312 {
1313 struct usb_device *udev = interface_to_usbdev(intf);
1314 struct gs_host_frame *hf;
1315 struct gs_usb *dev;
1316 struct gs_host_config hconf = {
1317 .byte_order = cpu_to_le32(0x0000beef),
1318 };
1319 struct gs_device_config dconf;
1320 unsigned int icount, i;
1321 int rc;
1322
1323 /* send host config */
1324 rc = usb_control_msg_send(udev, 0,
1325 GS_USB_BREQ_HOST_FORMAT,
1326 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1327 1, intf->cur_altsetting->desc.bInterfaceNumber,
1328 &hconf, sizeof(hconf), 1000,
1329 GFP_KERNEL);
1330 if (rc) {
1331 dev_err(&intf->dev, "Couldn't send data format (err=%d)\n", rc);
1332 return rc;
1333 }
1334
1335 /* read device config */
1336 rc = usb_control_msg_recv(udev, 0,
1337 GS_USB_BREQ_DEVICE_CONFIG,
1338 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1339 1, intf->cur_altsetting->desc.bInterfaceNumber,
1340 &dconf, sizeof(dconf), 1000,
1341 GFP_KERNEL);
1342 if (rc) {
1343 dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n",
1344 rc);
1345 return rc;
1346 }
1347
1348 icount = dconf.icount + 1;
1349 dev_info(&intf->dev, "Configuring for %u interfaces\n", icount);
1350
1351 if (icount > GS_MAX_INTF) {
1352 dev_err(&intf->dev,
1353 "Driver cannot handle more that %u CAN interfaces\n",
1354 GS_MAX_INTF);
1355 return -EINVAL;
1356 }
1357
1358 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1359 if (!dev)
1360 return -ENOMEM;
1361
1362 init_usb_anchor(&dev->rx_submitted);
1363
1364 usb_set_intfdata(intf, dev);
1365 dev->udev = udev;
1366
1367 for (i = 0; i < icount; i++) {
1368 unsigned int hf_size_rx = 0;
1369
1370 dev->canch[i] = gs_make_candev(i, intf, &dconf);
1371 if (IS_ERR_OR_NULL(dev->canch[i])) {
1372 /* save error code to return later */
1373 rc = PTR_ERR(dev->canch[i]);
1374
1375 /* on failure destroy previously created candevs */
1376 icount = i;
1377 for (i = 0; i < icount; i++)
1378 gs_destroy_candev(dev->canch[i]);
1379
1380 usb_kill_anchored_urbs(&dev->rx_submitted);
1381 kfree(dev);
1382 return rc;
1383 }
1384 dev->canch[i]->parent = dev;
1385
1386 /* set RX packet size based on FD and if hardware
1387 * timestamps are supported.
1388 */
1389 if (dev->canch[i]->can.ctrlmode_supported & CAN_CTRLMODE_FD) {
1390 if (dev->canch[i]->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
1391 hf_size_rx = struct_size(hf, canfd_ts, 1);
1392 else
1393 hf_size_rx = struct_size(hf, canfd, 1);
1394 } else {
1395 if (dev->canch[i]->feature & GS_CAN_FEATURE_HW_TIMESTAMP)
1396 hf_size_rx = struct_size(hf, classic_can_ts, 1);
1397 else
1398 hf_size_rx = struct_size(hf, classic_can, 1);
1399 }
1400 dev->hf_size_rx = max(dev->hf_size_rx, hf_size_rx);
1401 }
1402
1403 return 0;
1404 }
1405
gs_usb_disconnect(struct usb_interface * intf)1406 static void gs_usb_disconnect(struct usb_interface *intf)
1407 {
1408 struct gs_usb *dev = usb_get_intfdata(intf);
1409 unsigned int i;
1410
1411 usb_set_intfdata(intf, NULL);
1412
1413 if (!dev) {
1414 dev_err(&intf->dev, "Disconnect (nodata)\n");
1415 return;
1416 }
1417
1418 for (i = 0; i < GS_MAX_INTF; i++)
1419 if (dev->canch[i])
1420 gs_destroy_candev(dev->canch[i]);
1421
1422 usb_kill_anchored_urbs(&dev->rx_submitted);
1423 kfree(dev);
1424 }
1425
1426 static const struct usb_device_id gs_usb_table[] = {
1427 { USB_DEVICE_INTERFACE_NUMBER(USB_GS_USB_1_VENDOR_ID,
1428 USB_GS_USB_1_PRODUCT_ID, 0) },
1429 { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID,
1430 USB_CANDLELIGHT_PRODUCT_ID, 0) },
1431 { USB_DEVICE_INTERFACE_NUMBER(USB_CES_CANEXT_FD_VENDOR_ID,
1432 USB_CES_CANEXT_FD_PRODUCT_ID, 0) },
1433 { USB_DEVICE_INTERFACE_NUMBER(USB_ABE_CANDEBUGGER_FD_VENDOR_ID,
1434 USB_ABE_CANDEBUGGER_FD_PRODUCT_ID, 0) },
1435 {} /* Terminating entry */
1436 };
1437
1438 MODULE_DEVICE_TABLE(usb, gs_usb_table);
1439
1440 static struct usb_driver gs_usb_driver = {
1441 .name = KBUILD_MODNAME,
1442 .probe = gs_usb_probe,
1443 .disconnect = gs_usb_disconnect,
1444 .id_table = gs_usb_table,
1445 };
1446
1447 module_usb_driver(gs_usb_driver);
1448
1449 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>");
1450 MODULE_DESCRIPTION(
1451 "Socket CAN device driver for Geschwister Schneider Technologie-, "
1452 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
1453 "and bytewerk.org candleLight USB CAN interfaces.");
1454 MODULE_LICENSE("GPL v2");
1455
