gs_usb.c revision d08e973a77d128b25e01a08c34d89593fdf222da 
1/* CAN driver for Geschwister Schneider USB/CAN devices.
2 *
3 * Copyright (C) 2013 Geschwister Schneider Technologie-,
4 * Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
5 *
6 * Many thanks to all socketcan devs!
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18#include <linux/init.h>
19#include <linux/signal.h>
20#include <linux/module.h>
21#include <linux/netdevice.h>
22#include <linux/usb.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_GSUSB_1_VENDOR_ID      0x1d50
30#define USB_GSUSB_1_PRODUCT_ID     0x606f
31
32#define GSUSB_ENDPOINT_IN          1
33#define GSUSB_ENDPOINT_OUT         2
34
35/* Device specific constants */
36enum gs_usb_breq {
37	GS_USB_BREQ_HOST_FORMAT = 0,
38	GS_USB_BREQ_BITTIMING,
39	GS_USB_BREQ_MODE,
40	GS_USB_BREQ_BERR,
41	GS_USB_BREQ_BT_CONST,
42	GS_USB_BREQ_DEVICE_CONFIG
43};
44
45enum gs_can_mode {
46	/* reset a channel. turns it off */
47	GS_CAN_MODE_RESET = 0,
48	/* starts a channel */
49	GS_CAN_MODE_START
50};
51
52enum gs_can_state {
53	GS_CAN_STATE_ERROR_ACTIVE = 0,
54	GS_CAN_STATE_ERROR_WARNING,
55	GS_CAN_STATE_ERROR_PASSIVE,
56	GS_CAN_STATE_BUS_OFF,
57	GS_CAN_STATE_STOPPED,
58	GS_CAN_STATE_SLEEPING
59};
60
61/* data types passed between host and device */
62struct gs_host_config {
63	u32 byte_order;
64} __packed;
65/* All data exchanged between host and device is exchanged in host byte order,
66 * thanks to the struct gs_host_config byte_order member, which is sent first
67 * to indicate the desired byte order.
68 */
69
70struct gs_device_config {
71	u8 reserved1;
72	u8 reserved2;
73	u8 reserved3;
74	u8 icount;
75	u32 sw_version;
76	u32 hw_version;
77} __packed;
78
79#define GS_CAN_MODE_NORMAL               0
80#define GS_CAN_MODE_LISTEN_ONLY          (1<<0)
81#define GS_CAN_MODE_LOOP_BACK            (1<<1)
82#define GS_CAN_MODE_TRIPLE_SAMPLE        (1<<2)
83#define GS_CAN_MODE_ONE_SHOT             (1<<3)
84
85struct gs_device_mode {
86	u32 mode;
87	u32 flags;
88} __packed;
89
90struct gs_device_state {
91	u32 state;
92	u32 rxerr;
93	u32 txerr;
94} __packed;
95
96struct gs_device_bittiming {
97	u32 prop_seg;
98	u32 phase_seg1;
99	u32 phase_seg2;
100	u32 sjw;
101	u32 brp;
102} __packed;
103
104#define GS_CAN_FEATURE_LISTEN_ONLY      (1<<0)
105#define GS_CAN_FEATURE_LOOP_BACK        (1<<1)
106#define GS_CAN_FEATURE_TRIPLE_SAMPLE    (1<<2)
107#define GS_CAN_FEATURE_ONE_SHOT         (1<<3)
108
109struct gs_device_bt_const {
110	u32 feature;
111	u32 fclk_can;
112	u32 tseg1_min;
113	u32 tseg1_max;
114	u32 tseg2_min;
115	u32 tseg2_max;
116	u32 sjw_max;
117	u32 brp_min;
118	u32 brp_max;
119	u32 brp_inc;
120} __packed;
121
122#define GS_CAN_FLAG_OVERFLOW 1
123
124struct gs_host_frame {
125	u32 echo_id;
126	u32 can_id;
127
128	u8 can_dlc;
129	u8 channel;
130	u8 flags;
131	u8 reserved;
132
133	u8 data[8];
134} __packed;
135/* The GS USB devices make use of the same flags and masks as in
136 * linux/can.h and linux/can/error.h, and no additional mapping is necessary.
137 */
138
139/* Only send a max of GS_MAX_TX_URBS frames per channel at a time. */
140#define GS_MAX_TX_URBS 10
141/* Only launch a max of GS_MAX_RX_URBS usb requests at a time. */
142#define GS_MAX_RX_URBS 30
143/* Maximum number of interfaces the driver supports per device.
144 * Current hardware only supports 2 interfaces. The future may vary.
145 */
146#define GS_MAX_INTF 2
147
148struct gs_tx_context {
149	struct gs_can *dev;
150	unsigned int echo_id;
151};
152
153struct gs_can {
154	struct can_priv can; /* must be the first member */
155
156	struct gs_usb *parent;
157
158	struct net_device *netdev;
159	struct usb_device *udev;
160	struct usb_interface *iface;
161
162	struct can_bittiming_const bt_const;
163	unsigned int channel;	/* channel number */
164
165	/* This lock prevents a race condition between xmit and recieve. */
166	spinlock_t tx_ctx_lock;
167	struct gs_tx_context tx_context[GS_MAX_TX_URBS];
168
169	struct usb_anchor tx_submitted;
170	atomic_t active_tx_urbs;
171};
172
173/* usb interface struct */
174struct gs_usb {
175	struct gs_can *canch[GS_MAX_INTF];
176	struct usb_anchor rx_submitted;
177	atomic_t active_channels;
178	struct usb_device *udev;
179};
180
181/* 'allocate' a tx context.
182 * returns a valid tx context or NULL if there is no space.
183 */
184static struct gs_tx_context *gs_alloc_tx_context(struct gs_can *dev)
185{
186	int i = 0;
187	unsigned long flags;
188
189	spin_lock_irqsave(&dev->tx_ctx_lock, flags);
190
191	for (; i < GS_MAX_TX_URBS; i++) {
192		if (dev->tx_context[i].echo_id == GS_MAX_TX_URBS) {
193			dev->tx_context[i].echo_id = i;
194			spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
195			return &dev->tx_context[i];
196		}
197	}
198
199	spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
200	return NULL;
201}
202
203/* releases a tx context
204 */
205static void gs_free_tx_context(struct gs_tx_context *txc)
206{
207	txc->echo_id = GS_MAX_TX_URBS;
208}
209
210/* Get a tx context by id.
211 */
212static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev, unsigned int id)
213{
214	unsigned long flags;
215
216	if (id < GS_MAX_TX_URBS) {
217		spin_lock_irqsave(&dev->tx_ctx_lock, flags);
218		if (dev->tx_context[id].echo_id == id) {
219			spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
220			return &dev->tx_context[id];
221		}
222		spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
223	}
224	return NULL;
225}
226
227static int gs_cmd_reset(struct gs_usb *gsusb, struct gs_can *gsdev)
228{
229	struct gs_device_mode *dm;
230	struct usb_interface *intf = gsdev->iface;
231	int rc;
232
233	dm = kzalloc(sizeof(*dm), GFP_KERNEL);
234	if (!dm)
235		return -ENOMEM;
236
237	dm->mode = GS_CAN_MODE_RESET;
238
239	rc = usb_control_msg(interface_to_usbdev(intf),
240			     usb_sndctrlpipe(interface_to_usbdev(intf), 0),
241			     GS_USB_BREQ_MODE,
242			     USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
243			     gsdev->channel,
244			     0,
245			     dm,
246			     sizeof(*dm),
247			     1000);
248
249	return rc;
250}
251
252static void gs_update_state(struct gs_can *dev, struct can_frame *cf)
253{
254	struct can_device_stats *can_stats = &dev->can.can_stats;
255
256	if (cf->can_id & CAN_ERR_RESTARTED) {
257		dev->can.state = CAN_STATE_ERROR_ACTIVE;
258		can_stats->restarts++;
259	} else if (cf->can_id & CAN_ERR_BUSOFF) {
260		dev->can.state = CAN_STATE_BUS_OFF;
261		can_stats->bus_off++;
262	} else if (cf->can_id & CAN_ERR_CRTL) {
263		if ((cf->data[1] & CAN_ERR_CRTL_TX_WARNING) ||
264		    (cf->data[1] & CAN_ERR_CRTL_RX_WARNING)) {
265			dev->can.state = CAN_STATE_ERROR_WARNING;
266			can_stats->error_warning++;
267		} else if ((cf->data[1] & CAN_ERR_CRTL_TX_PASSIVE) ||
268			   (cf->data[1] & CAN_ERR_CRTL_RX_PASSIVE)) {
269			dev->can.state = CAN_STATE_ERROR_PASSIVE;
270			can_stats->error_passive++;
271		} else {
272			dev->can.state = CAN_STATE_ERROR_ACTIVE;
273		}
274	}
275}
276
277static void gs_usb_recieve_bulk_callback(struct urb *urb)
278{
279	struct gs_usb *usbcan = urb->context;
280	struct gs_can *dev;
281	struct net_device *netdev;
282	int rc;
283	struct net_device_stats *stats;
284	struct gs_host_frame *hf = urb->transfer_buffer;
285	struct gs_tx_context *txc;
286	struct can_frame *cf;
287	struct sk_buff *skb;
288
289	BUG_ON(!usbcan);
290
291	switch (urb->status) {
292	case 0: /* success */
293		break;
294	case -ENOENT:
295	case -ESHUTDOWN:
296		return;
297	default:
298		/* do not resubmit aborted urbs. eg: when device goes down */
299		return;
300	}
301
302	/* device reports out of range channel id */
303	if (hf->channel >= GS_MAX_INTF)
304		goto resubmit_urb;
305
306	dev = usbcan->canch[hf->channel];
307
308	netdev = dev->netdev;
309	stats = &netdev->stats;
310
311	if (!netif_device_present(netdev))
312		return;
313
314	if (hf->echo_id == -1) { /* normal rx */
315		skb = alloc_can_skb(dev->netdev, &cf);
316		if (!skb)
317			return;
318
319		cf->can_id = hf->can_id;
320
321		cf->can_dlc = get_can_dlc(hf->can_dlc);
322		memcpy(cf->data, hf->data, 8);
323
324		/* ERROR frames tell us information about the controller */
325		if (hf->can_id & CAN_ERR_FLAG)
326			gs_update_state(dev, cf);
327
328		netdev->stats.rx_packets++;
329		netdev->stats.rx_bytes += hf->can_dlc;
330
331		netif_rx(skb);
332	} else { /* echo_id == hf->echo_id */
333		if (hf->echo_id >= GS_MAX_TX_URBS) {
334			netdev_err(netdev,
335				   "Unexpected out of range echo id %d\n",
336				   hf->echo_id);
337			goto resubmit_urb;
338		}
339
340		netdev->stats.tx_packets++;
341		netdev->stats.tx_bytes += hf->can_dlc;
342
343		txc = gs_get_tx_context(dev, hf->echo_id);
344
345		/* bad devices send bad echo_ids. */
346		if (!txc) {
347			netdev_err(netdev,
348				   "Unexpected unused echo id %d\n",
349				   hf->echo_id);
350			goto resubmit_urb;
351		}
352
353		can_get_echo_skb(netdev, hf->echo_id);
354
355		gs_free_tx_context(txc);
356
357		netif_wake_queue(netdev);
358	}
359
360	if (hf->flags & GS_CAN_FLAG_OVERFLOW) {
361		skb = alloc_can_err_skb(netdev, &cf);
362		if (!skb)
363			goto resubmit_urb;
364
365		cf->can_id |= CAN_ERR_CRTL;
366		cf->can_dlc = CAN_ERR_DLC;
367		cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
368		stats->rx_over_errors++;
369		stats->rx_errors++;
370		netif_rx(skb);
371	}
372
373 resubmit_urb:
374	usb_fill_bulk_urb(urb,
375			  usbcan->udev,
376			  usb_rcvbulkpipe(usbcan->udev, GSUSB_ENDPOINT_IN),
377			  hf,
378			  sizeof(struct gs_host_frame),
379			  gs_usb_recieve_bulk_callback,
380			  usbcan
381			  );
382
383	rc = usb_submit_urb(urb, GFP_ATOMIC);
384
385	/* USB failure take down all interfaces */
386	if (rc == -ENODEV) {
387		for (rc = 0; rc < GS_MAX_INTF; rc++) {
388			if (usbcan->canch[rc])
389				netif_device_detach(usbcan->canch[rc]->netdev);
390		}
391	}
392}
393
394static int gs_usb_set_bittiming(struct net_device *netdev)
395{
396	struct gs_can *dev = netdev_priv(netdev);
397	struct can_bittiming *bt = &dev->can.bittiming;
398	struct usb_interface *intf = dev->iface;
399	int rc;
400	struct gs_device_bittiming *dbt;
401
402	dbt = kmalloc(sizeof(*dbt), GFP_KERNEL);
403	if (!dbt)
404		return -ENOMEM;
405
406	dbt->prop_seg = bt->prop_seg;
407	dbt->phase_seg1 = bt->phase_seg1;
408	dbt->phase_seg2 = bt->phase_seg2;
409	dbt->sjw = bt->sjw;
410	dbt->brp = bt->brp;
411
412	/* request bit timings */
413	rc = usb_control_msg(interface_to_usbdev(intf),
414			     usb_sndctrlpipe(interface_to_usbdev(intf), 0),
415			     GS_USB_BREQ_BITTIMING,
416			     USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
417			     dev->channel,
418			     0,
419			     dbt,
420			     sizeof(*dbt),
421			     1000);
422
423	kfree(dbt);
424
425	if (rc < 0)
426		dev_err(netdev->dev.parent, "Couldn't set bittimings (err=%d)",
427			rc);
428
429	return rc;
430}
431
432static void gs_usb_xmit_callback(struct urb *urb)
433{
434	struct gs_tx_context *txc = urb->context;
435	struct gs_can *dev = txc->dev;
436	struct net_device *netdev = dev->netdev;
437
438	if (urb->status)
439		netdev_info(netdev, "usb xmit fail %d\n", txc->echo_id);
440
441	usb_free_coherent(urb->dev,
442			  urb->transfer_buffer_length,
443			  urb->transfer_buffer,
444			  urb->transfer_dma);
445
446	atomic_dec(&dev->active_tx_urbs);
447
448	if (!netif_device_present(netdev))
449		return;
450
451	if (netif_queue_stopped(netdev))
452		netif_wake_queue(netdev);
453}
454
455static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, struct net_device *netdev)
456{
457	struct gs_can *dev = netdev_priv(netdev);
458	struct net_device_stats *stats = &dev->netdev->stats;
459	struct urb *urb;
460	struct gs_host_frame *hf;
461	struct can_frame *cf;
462	int rc;
463	unsigned int idx;
464	struct gs_tx_context *txc;
465
466	if (can_dropped_invalid_skb(netdev, skb))
467		return NETDEV_TX_OK;
468
469	/* find an empty context to keep track of transmission */
470	txc = gs_alloc_tx_context(dev);
471	if (!txc)
472		return NETDEV_TX_BUSY;
473
474	/* create a URB, and a buffer for it */
475	urb = usb_alloc_urb(0, GFP_ATOMIC);
476	if (!urb) {
477		netdev_err(netdev, "No memory left for URB\n");
478		goto nomem_urb;
479	}
480
481	hf = usb_alloc_coherent(dev->udev, sizeof(*hf), GFP_ATOMIC,
482				&urb->transfer_dma);
483	if (!hf) {
484		netdev_err(netdev, "No memory left for USB buffer\n");
485		goto nomem_hf;
486	}
487
488	idx = txc->echo_id;
489
490	if (idx >= GS_MAX_TX_URBS) {
491		netdev_err(netdev, "Invalid tx context %d\n", idx);
492		goto badidx;
493	}
494
495	hf->echo_id = idx;
496	hf->channel = dev->channel;
497
498	cf = (struct can_frame *)skb->data;
499
500	hf->can_id = cf->can_id;
501	hf->can_dlc = cf->can_dlc;
502	memcpy(hf->data, cf->data, cf->can_dlc);
503
504	usb_fill_bulk_urb(urb, dev->udev,
505			  usb_sndbulkpipe(dev->udev, GSUSB_ENDPOINT_OUT),
506			  hf,
507			  sizeof(*hf),
508			  gs_usb_xmit_callback,
509			  txc);
510
511	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
512	usb_anchor_urb(urb, &dev->tx_submitted);
513
514	can_put_echo_skb(skb, netdev, idx);
515
516	atomic_inc(&dev->active_tx_urbs);
517
518	rc = usb_submit_urb(urb, GFP_ATOMIC);
519	if (unlikely(rc)) {			/* usb send failed */
520		atomic_dec(&dev->active_tx_urbs);
521
522		can_free_echo_skb(netdev, idx);
523		gs_free_tx_context(txc);
524
525		usb_unanchor_urb(urb);
526		usb_free_coherent(dev->udev,
527				  sizeof(*hf),
528				  hf,
529				  urb->transfer_dma);
530
531
532		if (rc == -ENODEV) {
533			netif_device_detach(netdev);
534		} else {
535			netdev_err(netdev, "usb_submit failed (err=%d)\n", rc);
536			stats->tx_dropped++;
537		}
538	} else {
539		/* Slow down tx path */
540		if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS)
541			netif_stop_queue(netdev);
542	}
543
544	/* let usb core take care of this urb */
545	usb_free_urb(urb);
546
547	return NETDEV_TX_OK;
548
549 badidx:
550	usb_free_coherent(dev->udev,
551			  sizeof(*hf),
552			  hf,
553			  urb->transfer_dma);
554 nomem_hf:
555	usb_free_urb(urb);
556
557 nomem_urb:
558	gs_free_tx_context(txc);
559	dev_kfree_skb(skb);
560	stats->tx_dropped++;
561	return NETDEV_TX_OK;
562}
563
564static int gs_can_open(struct net_device *netdev)
565{
566	struct gs_can *dev = netdev_priv(netdev);
567	struct gs_usb *parent = dev->parent;
568	int rc, i;
569	struct gs_device_mode *dm;
570	u32 ctrlmode;
571
572	rc = open_candev(netdev);
573	if (rc)
574		return rc;
575
576	if (atomic_add_return(1, &parent->active_channels) == 1) {
577		for (i = 0; i < GS_MAX_RX_URBS; i++) {
578			struct urb *urb;
579			u8 *buf;
580
581			/* alloc rx urb */
582			urb = usb_alloc_urb(0, GFP_KERNEL);
583			if (!urb) {
584				netdev_err(netdev,
585					   "No memory left for URB\n");
586				return -ENOMEM;
587			}
588
589			/* alloc rx buffer */
590			buf = usb_alloc_coherent(dev->udev,
591						 sizeof(struct gs_host_frame),
592						 GFP_KERNEL,
593						 &urb->transfer_dma);
594			if (!buf) {
595				netdev_err(netdev,
596					   "No memory left for USB buffer\n");
597				usb_free_urb(urb);
598				return -ENOMEM;
599			}
600
601			/* fill, anchor, and submit rx urb */
602			usb_fill_bulk_urb(urb,
603					  dev->udev,
604					  usb_rcvbulkpipe(dev->udev,
605							  GSUSB_ENDPOINT_IN),
606					  buf,
607					  sizeof(struct gs_host_frame),
608					  gs_usb_recieve_bulk_callback,
609					  parent);
610			urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
611
612			usb_anchor_urb(urb, &parent->rx_submitted);
613
614			rc = usb_submit_urb(urb, GFP_KERNEL);
615			if (rc) {
616				if (rc == -ENODEV)
617					netif_device_detach(dev->netdev);
618
619				netdev_err(netdev,
620					   "usb_submit failed (err=%d)\n",
621					   rc);
622
623				usb_unanchor_urb(urb);
624				break;
625			}
626
627			/* Drop reference,
628			 * USB core will take care of freeing it
629			 */
630			usb_free_urb(urb);
631		}
632	}
633
634	dm = kmalloc(sizeof(*dm), GFP_KERNEL);
635	if (!dm)
636		return -ENOMEM;
637
638	/* flags */
639	ctrlmode = dev->can.ctrlmode;
640	dm->flags = 0;
641
642	if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
643		dm->flags |= GS_CAN_MODE_LOOP_BACK;
644	else if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
645		dm->flags |= GS_CAN_MODE_LISTEN_ONLY;
646
647	/* Controller is not allowed to retry TX
648	 * this mode is unavailable on atmels uc3c hardware
649	 */
650	if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
651		dm->flags |= GS_CAN_MODE_ONE_SHOT;
652
653	if (ctrlmode & CAN_CTRLMODE_3_SAMPLES)
654		dm->flags |= GS_CAN_MODE_TRIPLE_SAMPLE;
655
656	/* finally start device */
657	dm->mode = GS_CAN_MODE_START;
658	rc = usb_control_msg(interface_to_usbdev(dev->iface),
659			     usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0),
660			     GS_USB_BREQ_MODE,
661			     USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
662			     dev->channel,
663			     0,
664			     dm,
665			     sizeof(*dm),
666			     1000);
667
668	if (rc < 0) {
669		netdev_err(netdev, "Couldn't start device (err=%d)\n", rc);
670		kfree(dm);
671		return rc;
672	}
673
674	kfree(dm);
675
676	dev->can.state = CAN_STATE_ERROR_ACTIVE;
677
678	if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
679		netif_start_queue(netdev);
680
681	return 0;
682}
683
684static int gs_can_close(struct net_device *netdev)
685{
686	int rc;
687	struct gs_can *dev = netdev_priv(netdev);
688	struct gs_usb *parent = dev->parent;
689
690	netif_stop_queue(netdev);
691
692	/* Stop polling */
693	if (atomic_dec_and_test(&parent->active_channels))
694		usb_kill_anchored_urbs(&parent->rx_submitted);
695
696	/* Stop sending URBs */
697	usb_kill_anchored_urbs(&dev->tx_submitted);
698	atomic_set(&dev->active_tx_urbs, 0);
699
700	/* reset the device */
701	rc = gs_cmd_reset(parent, dev);
702	if (rc < 0)
703		netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc);
704
705	/* reset tx contexts */
706	for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
707		dev->tx_context[rc].dev = dev;
708		dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
709	}
710
711	/* close the netdev */
712	close_candev(netdev);
713
714	return 0;
715}
716
717static const struct net_device_ops gs_usb_netdev_ops = {
718	.ndo_open = gs_can_open,
719	.ndo_stop = gs_can_close,
720	.ndo_start_xmit = gs_can_start_xmit,
721};
722
723static struct gs_can *gs_make_candev(unsigned int channel, struct usb_interface *intf)
724{
725	struct gs_can *dev;
726	struct net_device *netdev;
727	int rc;
728	struct gs_device_bt_const *bt_const;
729
730	bt_const = kmalloc(sizeof(*bt_const), GFP_KERNEL);
731	if (!bt_const)
732		return ERR_PTR(-ENOMEM);
733
734	/* fetch bit timing constants */
735	rc = usb_control_msg(interface_to_usbdev(intf),
736			     usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
737			     GS_USB_BREQ_BT_CONST,
738			     USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
739			     channel,
740			     0,
741			     bt_const,
742			     sizeof(*bt_const),
743			     1000);
744
745	if (rc < 0) {
746		dev_err(&intf->dev,
747			"Couldn't get bit timing const for channel (err=%d)\n",
748			rc);
749		kfree(bt_const);
750		return ERR_PTR(rc);
751	}
752
753	/* create netdev */
754	netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS);
755	if (!netdev) {
756		dev_err(&intf->dev, "Couldn't allocate candev\n");
757		kfree(bt_const);
758		return ERR_PTR(-ENOMEM);
759	}
760
761	dev = netdev_priv(netdev);
762
763	netdev->netdev_ops = &gs_usb_netdev_ops;
764
765	netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */
766
767	/* dev settup */
768	strcpy(dev->bt_const.name, "gs_usb");
769	dev->bt_const.tseg1_min = bt_const->tseg1_min;
770	dev->bt_const.tseg1_max = bt_const->tseg1_max;
771	dev->bt_const.tseg2_min = bt_const->tseg2_min;
772	dev->bt_const.tseg2_max = bt_const->tseg2_max;
773	dev->bt_const.sjw_max = bt_const->sjw_max;
774	dev->bt_const.brp_min = bt_const->brp_min;
775	dev->bt_const.brp_max = bt_const->brp_max;
776	dev->bt_const.brp_inc = bt_const->brp_inc;
777
778	dev->udev = interface_to_usbdev(intf);
779	dev->iface = intf;
780	dev->netdev = netdev;
781	dev->channel = channel;
782
783	init_usb_anchor(&dev->tx_submitted);
784	atomic_set(&dev->active_tx_urbs, 0);
785	spin_lock_init(&dev->tx_ctx_lock);
786	for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
787		dev->tx_context[rc].dev = dev;
788		dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
789	}
790
791	/* can settup */
792	dev->can.state = CAN_STATE_STOPPED;
793	dev->can.clock.freq = bt_const->fclk_can;
794	dev->can.bittiming_const = &dev->bt_const;
795	dev->can.do_set_bittiming = gs_usb_set_bittiming;
796
797	dev->can.ctrlmode_supported = 0;
798
799	if (bt_const->feature & GS_CAN_FEATURE_LISTEN_ONLY)
800		dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
801
802	if (bt_const->feature & GS_CAN_FEATURE_LOOP_BACK)
803		dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK;
804
805	if (bt_const->feature & GS_CAN_FEATURE_TRIPLE_SAMPLE)
806		dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
807
808	if (bt_const->feature & GS_CAN_FEATURE_ONE_SHOT)
809		dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
810
811	kfree(bt_const);
812
813	SET_NETDEV_DEV(netdev, &intf->dev);
814
815	rc = register_candev(dev->netdev);
816	if (rc) {
817		free_candev(dev->netdev);
818		dev_err(&intf->dev, "Couldn't register candev (err=%d)\n", rc);
819		return ERR_PTR(rc);
820	}
821
822	return dev;
823}
824
825static void gs_destroy_candev(struct gs_can *dev)
826{
827	unregister_candev(dev->netdev);
828	free_candev(dev->netdev);
829	kfree(dev);
830	usb_kill_anchored_urbs(&dev->tx_submitted);
831}
832
833static int gs_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
834{
835	struct gs_usb *dev;
836	int rc = -ENOMEM;
837	unsigned int icount, i;
838	struct gs_host_config *hconf;
839	struct gs_device_config *dconf;
840
841	hconf = kmalloc(sizeof(*hconf), GFP_KERNEL);
842	if (!hconf)
843		return -ENOMEM;
844
845	hconf->byte_order = 0x0000beef;
846
847	/* send host config */
848	rc = usb_control_msg(interface_to_usbdev(intf),
849			     usb_sndctrlpipe(interface_to_usbdev(intf), 0),
850			     GS_USB_BREQ_HOST_FORMAT,
851			     USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
852			     1,
853			     intf->altsetting[0].desc.bInterfaceNumber,
854			     hconf,
855			     sizeof(*hconf),
856			     1000);
857
858	kfree(hconf);
859
860	if (rc < 0) {
861		dev_err(&intf->dev, "Couldn't send data format (err=%d)\n",
862			rc);
863		return rc;
864	}
865
866	dconf = kmalloc(sizeof(*dconf), GFP_KERNEL);
867	if (!dconf)
868		return -ENOMEM;
869
870	/* read device config */
871	rc = usb_control_msg(interface_to_usbdev(intf),
872			     usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
873			     GS_USB_BREQ_DEVICE_CONFIG,
874			     USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
875			     1,
876			     intf->altsetting[0].desc.bInterfaceNumber,
877			     dconf,
878			     sizeof(*dconf),
879			     1000);
880	if (rc < 0) {
881		dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n",
882			rc);
883
884		kfree(dconf);
885
886		return rc;
887	}
888
889	icount = dconf->icount+1;
890
891	kfree(dconf);
892
893	dev_info(&intf->dev, "Configuring for %d interfaces\n", icount);
894
895	if (icount > GS_MAX_INTF) {
896		dev_err(&intf->dev,
897			"Driver cannot handle more that %d CAN interfaces\n",
898			GS_MAX_INTF);
899		return -EINVAL;
900	}
901
902	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
903	init_usb_anchor(&dev->rx_submitted);
904
905	atomic_set(&dev->active_channels, 0);
906
907	usb_set_intfdata(intf, dev);
908	dev->udev = interface_to_usbdev(intf);
909
910	for (i = 0; i < icount; i++) {
911		dev->canch[i] = gs_make_candev(i, intf);
912		if (IS_ERR_OR_NULL(dev->canch[i])) {
913			/* on failure destroy previously created candevs */
914			icount = i;
915			for (i = 0; i < icount; i++) {
916				gs_destroy_candev(dev->canch[i]);
917				dev->canch[i] = NULL;
918			}
919			kfree(dev);
920			return rc;
921		}
922		dev->canch[i]->parent = dev;
923	}
924
925	return 0;
926}
927
928static void gs_usb_disconnect(struct usb_interface *intf)
929{
930	unsigned i;
931	struct gs_usb *dev = usb_get_intfdata(intf);
932	usb_set_intfdata(intf, NULL);
933
934	if (!dev) {
935		dev_err(&intf->dev, "Disconnect (nodata)\n");
936		return;
937	}
938
939	for (i = 0; i < GS_MAX_INTF; i++) {
940		struct gs_can *can = dev->canch[i];
941
942		if (!can)
943			continue;
944
945		gs_destroy_candev(can);
946	}
947
948	usb_kill_anchored_urbs(&dev->rx_submitted);
949}
950
951static const struct usb_device_id gs_usb_table[] = {
952	{USB_DEVICE(USB_GSUSB_1_VENDOR_ID, USB_GSUSB_1_PRODUCT_ID)},
953	{} /* Terminating entry */
954};
955
956MODULE_DEVICE_TABLE(usb, gs_usb_table);
957
958static struct usb_driver gs_usb_driver = {
959	.name       = "gs_usb",
960	.probe      = gs_usb_probe,
961	.disconnect = gs_usb_disconnect,
962	.id_table   = gs_usb_table,
963};
964
965module_usb_driver(gs_usb_driver);
966
967MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>");
968MODULE_DESCRIPTION(
969"Socket CAN device driver for Geschwister Schneider Technologie-, "
970"Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces.");
971MODULE_LICENSE("GPL v2");
972