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