1 #include <linux/kernel.h>
2 #include <linux/errno.h>
3 #include <linux/init.h>
4 #include <linux/slab.h>
5 #include <linux/module.h>
6 #include <linux/kref.h>
7 #include <linux/uaccess.h>
9 #include <linux/mutex.h>
10 #include <linux/netdevice.h>
11 #include <linux/version.h>
12 #include <linux/kthread.h>
13 #include <linux/freezer.h>
15 #include <linux/can.h>
16 #include <linux/can/dev.h>
17 #include <linux/can/error.h>
19 // USBCAN - new usb vendor definitions
20 #define USBCAN_VENDOR_SET_BITTIMING (9)
21 #define USBCAN_VENDOR_GET_BITTIMING_CONST (10)
23 #define CTU_USBCAN_VENDOR_ID 0x1669
24 #define CTU_USBCAN_PRODUCT_ID 0x1011
26 #define USBCAN_TOT_RX_URBS 8
27 #define USBCAN_TOT_TX_URBS 8
29 #define USBCAN_TRANSFER_SIZE 16
30 #define USBCAN_BITTIMING_SIZE 16
31 #define USBCAN_BITTIMING_CONST_SIZE 36
33 #define CAN_MSG_LENGTH 8
35 #define MSG_RTR (1<<0)
36 #define MSG_OVR (1<<1)
37 #define MSG_EXT (1<<2)
38 #define MSG_LOCAL (1<<3)
40 #define USBCAN_DATA_OK (1)
41 #define USBCAN_TX_PENDING (2)
42 #define USBCAN_BITTIMING_CONST_SET (3)
45 MODULE_LICENSE("GPL");
47 /* table of devices that work with this driver */
48 static struct usb_device_id ctu_usbcan_table [] = {
49 { USB_DEVICE(CTU_USBCAN_VENDOR_ID, CTU_USBCAN_PRODUCT_ID) },
50 { } /* Terminating entry */
52 MODULE_DEVICE_TABLE(usb, ctu_usbcan_table);
55 static struct usb_driver ctu_usbcan_driver;
56 struct ctu_usbcan_usb;
59 struct usbcan_message {
61 struct ctu_usbcan_usb *dev;
62 u8 msg[USBCAN_TRANSFER_SIZE];
65 struct list_head list_node;
68 Structure of byte array msg in struct usbcan_message that represents CAN message (little endian):
69 msg[0] - reserved (1 byte)
70 msg[1] - length (1 byte)
71 msg[2:3] - flags (2 bytes)
72 msg[4:7] - id (4 bytes)
73 msg[8:15] - data (8 bytes)
77 /* Structure to hold all of our device specific stuff */
78 struct ctu_usbcan_usb {
80 struct can_priv can; /* must be the first member */
82 struct can_bittiming_const btc;
85 struct usb_device *udev; /* the usb device for this device */
86 struct net_device *netdev;
88 u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
89 u8 bulk_out_endpointAddr; /* the address of the bulk out endpoint */
91 struct list_head rx_pend_list; /* URBs waiting for data receive */
92 struct list_head rx_ready_list; /* URBs with valid received data */
93 struct list_head tx_idle_list; /* URBs prepared to hold Tx messages */
94 struct list_head tx_pend_list; /* URBs holding Tx messages in progress */
95 struct list_head tx_ready_list; /* URBs with yet confirmed Tx messages */
97 spinlock_t list_lock; /* list lock */
98 struct task_struct *comthread; /* usb communication kernel thread */
105 static void usbcan_usb_message_move_list(struct ctu_usbcan_usb *dev,
106 struct usbcan_message *m, struct list_head *head)
109 spin_lock_irqsave(&dev->list_lock, flags);
110 list_del(&m->list_node);
111 list_add_tail(&m->list_node, head);
112 spin_unlock_irqrestore(&dev->list_lock, flags);
116 static int get_bittiming_constants(struct ctu_usbcan_usb *dev)
123 usbbuf = kzalloc(sizeof(u8)*USBCAN_BITTIMING_CONST_SIZE, GFP_KERNEL);
126 err("Error allocating receive buffer for bittiming constants\n");
130 retval = usb_control_msg(dev->udev,
131 usb_rcvctrlpipe(dev->udev, 0),
132 USBCAN_VENDOR_GET_BITTIMING_CONST,
134 cpu_to_le16(0), cpu_to_le16(0),
135 usbbuf, USBCAN_BITTIMING_CONST_SIZE,
143 dev->can_clock = le32_to_cpu(*(ptr++));
144 dev->btc.tseg1_min = le32_to_cpu(*(ptr++));
145 dev->btc.tseg1_max = le32_to_cpu(*(ptr++));
146 dev->btc.tseg2_min = le32_to_cpu(*(ptr++));
147 dev->btc.tseg2_max = le32_to_cpu(*(ptr++));
148 dev->btc.sjw_max = le32_to_cpu(*(ptr++));
149 dev->btc.brp_min = le32_to_cpu(*(ptr++));
150 dev->btc.brp_max = le32_to_cpu(*(ptr++));
151 dev->btc.brp_inc = le32_to_cpu(*(ptr));
153 set_bit(USBCAN_BITTIMING_CONST_SET,&dev->flags);
166 static int ctu_usbcan_set_mode(struct net_device *netdev, enum can_mode mode)
169 printk("SET MODE\n");
174 static int ctu_usbcan_set_bittiming(struct net_device *netdev)
176 struct ctu_usbcan_usb *dev = netdev_priv(netdev);
177 struct can_bittiming *bt = &dev->can.bittiming;
187 usbbuf = kzalloc(sizeof(u8)*USBCAN_BITTIMING_SIZE, GFP_KERNEL);
190 err("Error allocating transmit buffer for set bittiming\n");
196 *(ptr++)=cpu_to_le32(bt->brp); // baudrate prescaler
197 *(ptr++)=cpu_to_le32(bt->sjw); // sjw
198 *(ptr++)=cpu_to_le32(bt->prop_seg + bt->phase_seg1); // TSEG1
199 *(ptr)=cpu_to_le32(bt->phase_seg2); // TSEG2
202 retval = usb_control_msg(dev->udev,
203 usb_sndctrlpipe(dev->udev, 0),
204 USBCAN_VENDOR_SET_BITTIMING,
206 cpu_to_le16(0), cpu_to_le16(0),
207 usbbuf, USBCAN_BITTIMING_SIZE,
213 printk("BITRATE %d, BRP: %d, SJW: %d, TSEG1: %d, TSEG2: %d \n", bt->bitrate, bt->brp, bt->sjw,\
214 (bt->prop_seg + bt->phase_seg1), bt->phase_seg2);
218 err("Could not set bittiming\n");
225 static void ctu_usbcan_tx_callback(struct urb *urb){
227 struct usbcan_message *m = urb->context;
228 struct net_device_stats *stats = &m->dev->netdev->stats;
230 if (!netif_device_present(m->dev->netdev))
233 if (urb->status != 0){
234 err("TX callback: error");
240 //printk("TX callback: URB successfully transmitted\n");
243 stats->tx_bytes += m->dlc;
246 can_get_echo_skb(m->dev->netdev, m->echo_index);
248 set_bit(USBCAN_DATA_OK,&m->dev->flags);
249 usbcan_usb_message_move_list(m->dev, m, &m->dev->tx_ready_list);
250 wake_up_process(m->dev->comthread);
254 static void ctu_usbcan_rx_callback(struct urb *urb)
257 struct usbcan_message *m = urb->context;
259 if (!netif_device_present(m->dev->netdev))
263 if(urb->status != 0){
264 err("RX callback: error");
270 //printk("RX callback: URB successfully received\n");
272 set_bit(USBCAN_DATA_OK,&m->dev->flags);
273 usbcan_usb_message_move_list(m->dev, m, &m->dev->rx_ready_list);
274 wake_up_process(m->dev->comthread);
278 static netdev_tx_t ctu_usbcan_start_xmit(struct sk_buff *skb, struct net_device *netdev)
280 struct ctu_usbcan_usb *dev = netdev_priv(netdev);
281 struct can_frame *cf = (struct can_frame *)skb->data;
282 struct usbcan_message *m;
288 if(list_empty(&dev->tx_idle_list)){
292 m = list_first_entry(&dev->tx_idle_list, typeof(*m), list_node);
297 if(len > CAN_MSG_LENGTH)
298 len = CAN_MSG_LENGTH;
300 if (cf->can_id & CAN_RTR_FLAG)
303 if (cf->can_id & CAN_EFF_FLAG)
307 *(u8 *)(m->msg+1)=len & 0xFF;
308 *(u16 *)(m->msg+2)=cpu_to_le16(flags);
309 *(u32 *)(m->msg+4)=cpu_to_le32(cf->can_id & CAN_ERR_MASK);
311 for(ptr=m->msg+8, i=0; i < len; ptr++,i++)
312 *ptr= cf->data[i] & 0xFF;
314 for(; i < 8; ptr++,i++)
320 usbcan_usb_message_move_list(dev, m, &dev->tx_pend_list);
322 /* put on stack - local echo */
323 can_put_echo_skb(skb, netdev, m->echo_index);
326 retval = usb_submit_urb(m->u, GFP_ATOMIC);
328 err("Error submitting URB: %d", retval);
329 can_free_echo_skb(netdev, m->echo_index);
330 usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
335 /* slow down tx path if needed */
336 if(list_empty(&dev->tx_idle_list))
337 netif_stop_queue(netdev);
347 static void usbcan_kthread_free_urbs(struct ctu_usbcan_usb *dev)
349 while(!list_empty(&dev->rx_pend_list)) {
350 struct usbcan_message *m;
351 m = list_first_entry(&dev->rx_pend_list, typeof(*m), list_node);
353 usbcan_usb_message_move_list(dev, m, &dev->rx_ready_list);
356 while(!list_empty(&dev->tx_pend_list)) {
357 struct usbcan_message *m;
358 m = list_first_entry(&dev->tx_pend_list, typeof(*m), list_node);
360 usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
363 while(!list_empty(&dev->rx_ready_list)) {
364 struct usbcan_message *m;
365 m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
366 list_del(&m->list_node);
371 while(!list_empty(&dev->tx_ready_list)) {
372 struct usbcan_message *m;
373 m = list_first_entry(&dev->tx_ready_list, typeof(*m), list_node);
374 list_del(&m->list_node);
379 while(!list_empty(&dev->tx_idle_list)) {
380 struct usbcan_message *m;
381 m = list_first_entry(&dev->tx_idle_list, typeof(*m), list_node);
382 list_del(&m->list_node);
390 void usbcan_kthread_write_handler(struct ctu_usbcan_usb *dev, struct usbcan_message *m)
393 usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
395 if (netif_queue_stopped(m->dev->netdev))
396 netif_wake_queue(m->dev->netdev);
400 void usbcan_kthread_read_handler(struct ctu_usbcan_usb *dev, struct usbcan_message *m)
403 struct can_frame *cf;
408 struct net_device_stats *stats = &m->dev->netdev->stats;
411 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)
412 skb = alloc_can_skb(m->dev->netdev, &cf);
414 skb = netdev_alloc_skb(m->dev->netdev, sizeof(struct can_frame));
415 skb->protocol = htons(ETH_P_CAN);
416 cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
420 err("RX: error alloc skb\n");
425 //printk("RX: URB successfully received\n");
427 len=*(u8 *)(m->msg+1);
428 if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
430 flags = le16_to_cpu(*(u16 *)(m->msg+2));
431 cf->can_id = le32_to_cpu((*(u32 *)(m->msg+4)));
434 cf->can_id |= CAN_RTR_FLAG;
437 cf->can_id |= CAN_EFF_FLAG;
441 for(ptr=m->msg+8,i=0; i < len; ptr++,i++) {
449 stats->rx_bytes += cf->can_dlc;
451 /* Renewing RX urb */
453 usbcan_usb_message_move_list(dev, m, &dev->rx_pend_list);
454 retval = usb_submit_urb (m->u, GFP_KERNEL);
456 err("URB error %d\n", retval);
463 static int usbcan_sleep_thread(struct ctu_usbcan_usb *dev)
467 /* Wait until a signal arrives or we are woken up */
470 set_current_state(TASK_INTERRUPTIBLE);
471 if (signal_pending(current)) {
476 kthread_should_stop() ||
477 test_bit(USBCAN_DATA_OK,&dev->flags)
482 __set_current_state(TASK_RUNNING);
486 int usbcan_kthread(void *data)
489 struct ctu_usbcan_usb *dev=(struct ctu_usbcan_usb *) data;
493 struct usbcan_message *m;
496 printk("CTU USBCAN: kthread running\n");
498 INIT_LIST_HEAD(&dev->rx_pend_list);
499 INIT_LIST_HEAD(&dev->rx_ready_list);
500 INIT_LIST_HEAD(&dev->tx_idle_list);
501 INIT_LIST_HEAD(&dev->tx_pend_list);
502 INIT_LIST_HEAD(&dev->tx_ready_list);
504 /* Prepare receive urbs */
505 for (i=0;i<USBCAN_TOT_RX_URBS;i++){
507 u = usb_alloc_urb(0, GFP_KERNEL);
508 m = kzalloc(sizeof(struct usbcan_message), GFP_KERNEL);
511 err("Error allocating usb receive urb");
517 err("Error allocating receive usbcan_message");
523 usb_fill_bulk_urb(u, dev->udev,
524 usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
525 m->msg, USBCAN_TRANSFER_SIZE, ctu_usbcan_rx_callback, m);
528 list_add_tail(&m->list_node, &dev->rx_ready_list);
531 /* Prepare transmit urbs */
532 for (i=0;i<USBCAN_TOT_TX_URBS;i++){
534 u = usb_alloc_urb(0, GFP_KERNEL);
535 m = kzalloc(sizeof(struct usbcan_message), GFP_KERNEL);
538 err("Error allocating usb transmit urb");
544 err("Error allocating transmit usbcan_message");
553 usb_fill_bulk_urb(u, dev->udev,
554 usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
555 m->msg, USBCAN_TRANSFER_SIZE, ctu_usbcan_tx_callback, m);
557 list_add_tail(&m->list_node, &dev->tx_idle_list);
561 for (i=0;i<USBCAN_TOT_RX_URBS;i++){
563 m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
564 usbcan_usb_message_move_list(dev, m, &dev->rx_pend_list);
566 retval=usb_submit_urb(m->u, GFP_KERNEL);
568 err("Error submitting URB: %d", retval);
575 /* an endless loop in which we are doing our work */
580 /* We need to do a memory barrier here to be sure that
581 the flags are visible on all CPUs. */
585 if (!kthread_should_stop() && (usbcan_sleep_thread(dev)<0)){
588 /* We need to do a memory barrier here to be sure that the flags are visible on all CPUs. */
591 if (kthread_should_stop()){
597 clear_bit(USBCAN_DATA_OK,&dev->flags);
600 while(!list_empty(&dev->rx_ready_list)) {
601 struct usbcan_message *m;
602 m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
603 usbcan_kthread_read_handler(dev, m);
606 while(!list_empty(&dev->tx_ready_list)) {
607 struct usbcan_message *m;
608 m = list_first_entry(&dev->tx_ready_list, typeof(*m), list_node);
609 usbcan_kthread_write_handler(dev, m);
616 usbcan_kthread_free_urbs(dev);
617 printk("CTU USBCAN: usbcan thread finished\n");
623 static int ctu_usbcan_open(struct net_device *netdev)
627 struct ctu_usbcan_usb *dev = netdev_priv(netdev);
630 err = open_candev(netdev);
634 /* start transmit queue */
635 netif_start_queue(netdev);
637 /* start kernel thread */
638 dev->comthread = kthread_run(usbcan_kthread, (void *)dev, "usbcan_1");
643 static int ctu_usbcan_close(struct net_device *netdev)
646 struct ctu_usbcan_usb *dev = netdev_priv(netdev);
647 kthread_stop(dev->comthread);
649 netif_stop_queue(netdev);
651 close_candev(netdev);
656 static const struct net_device_ops ctu_usbcan_netdev_ops = {
657 .ndo_open = ctu_usbcan_open,
658 .ndo_stop = ctu_usbcan_close,
659 .ndo_start_xmit = ctu_usbcan_start_xmit,
663 static int ctu_usbcan_probe(struct usb_interface *intf,
664 const struct usb_device_id *id)
666 struct net_device *netdev;
667 struct ctu_usbcan_usb *dev;
668 struct usb_host_interface *iface_desc;
669 struct usb_endpoint_descriptor *endpoint;
673 printk(KERN_INFO "CTU USBCAN device now attached\n");
676 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)
677 netdev = alloc_candev(sizeof(struct ctu_usbcan_usb), USBCAN_TOT_TX_URBS);
679 netdev = alloc_candev(sizeof(struct ctu_usbcan_usb));
683 dev_err(&intf->dev, "Couldn't alloc candev\n");
687 dev = netdev_priv(netdev);
689 dev->udev = interface_to_usbdev(intf);
690 dev->netdev = netdev;
693 netdev->netdev_ops = &ctu_usbcan_netdev_ops;
694 netdev->flags |= IFF_ECHO;
697 /* set up the endpoint information */
698 /* use only the first bulk-in and bulk-out endpoints */
699 iface_desc = intf->cur_altsetting;
700 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
701 endpoint = &iface_desc->endpoint[i].desc;
703 if (!dev->bulk_in_endpointAddr &&
704 usb_endpoint_is_bulk_in(endpoint)) {
705 /* we found a bulk in endpoint */
706 dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
709 if (!dev->bulk_out_endpointAddr &&
710 usb_endpoint_is_bulk_out(endpoint)) {
711 /* we found a bulk out endpoint */
712 dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
715 if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
716 err("Could not find both bulk-in and bulk-out endpoints");
721 usb_set_intfdata(intf, dev);
722 SET_NETDEV_DEV(netdev, &intf->dev);
724 if (get_bittiming_constants(dev)){
725 err("Could not get bittiming constants\n");
729 dev->can.clock.freq = dev->can_clock;
730 dev->can.bittiming_const = &dev->btc;
731 dev->can.do_set_bittiming = ctu_usbcan_set_bittiming;
732 dev->can.do_set_mode = ctu_usbcan_set_mode;
735 err = register_candev(netdev);
737 dev_err(netdev->dev.parent,
738 "couldn't register CAN device: %d\n", err);
746 /* called by the usb core when the device is removed from the system */
747 static void ctu_usbcan_disconnect(struct usb_interface *intf)
750 struct ctu_usbcan_usb *dev = usb_get_intfdata(intf);
752 printk(KERN_INFO "CTU USBCAN device now disconnected\n");
754 usb_set_intfdata(intf, NULL);
757 if(test_bit(USBCAN_BITTIMING_CONST_SET,&dev->flags))
758 unregister_netdev(dev->netdev);
760 free_candev(dev->netdev);
761 clear_bit(USBCAN_BITTIMING_CONST_SET,&dev->flags);
766 /* usb specific object needed to register this driver with the usb subsystem */
767 static struct usb_driver ctu_usbcan_driver = {
768 .name = "ctu_usbcan",
769 .id_table = ctu_usbcan_table,
770 .probe = ctu_usbcan_probe,
771 .disconnect = ctu_usbcan_disconnect,
774 static int __init ctu_usbcan_init(void)
778 printk(KERN_INFO "CTU USBCAN kernel driver loaded\n");
780 /* register this driver with the USB subsystem */
781 result = usb_register(&ctu_usbcan_driver);
783 err("usb_register failed. Error number %d", result);
788 static void __exit ctu_usbcan_exit(void)
790 printk(KERN_INFO "CTU USBCAN kernel driver unloaded\n");
792 /* deregister this driver with the USB subsystem */
793 usb_deregister(&ctu_usbcan_driver);
796 module_init(ctu_usbcan_init);
797 module_exit(ctu_usbcan_exit);