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