X-Git-Url: http://rtime.felk.cvut.cz/gitweb/lincan.git/blobdiff_plain/302f7b23bb1f40fd1c8f3010f6ff4d6a44ac566e..1a157d7de03aaf7887a59fae6fbd62eec854aede:/lincan/src/usbcan.c

diff --git a/lincan/src/usbcan.c b/lincan/src/usbcan.c
index 42ece6f..01d2f90 100644
--- a/lincan/src/usbcan.c
+++ b/lincan/src/usbcan.c
@@ -12,6 +12,10 @@
 #include "../include/setup.h"
 #include "../include/usbcan.h"
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
+ #include <linux/freezer.h>
+#endif
+
 static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id);
 static void usbcan_disconnect(struct usb_interface *interface);
 
@@ -173,12 +177,13 @@ int usbcan_register(struct hwspecops_t *hwspecops)
 
 // static int sja1000_report_error_limit_counter;
 
-static void sja1000_report_error(struct canchip_t *chip,
+static void usbcan_report_error(struct canchip_t *chip,
 				unsigned sr, unsigned ir, unsigned ecc)
 {
 	/*TODO : Error reporting from device */
 
-/*	if(sja1000_report_error_limit_counter>=100)
+#if 0
+	if(sja1000_report_error_limit_counter>=100)
 		return;
 
 	CANMSG("Error: status register: 0x%x irq_register: 0x%02x error: 0x%02x\n",
@@ -211,6 +216,7 @@ static void sja1000_report_error(struct canchip_t *chip,
 		      );
 	}
 #endif /*CONFIG_OC_LINCAN_DETAILED_ERRORS*/
+#endif
 }
 
 
@@ -519,7 +525,7 @@ int usbcan_chip_queue_status(struct canchip_t *chip)
 	10000);
 
 	if (retval==1){
-		CANMSG("Chip_queue_status: %d\n",buf[0]);
+		DEBUGMSG("Chip_queue_status: %d\n",buf[0]);
 		if(buf[0]==1)
 			return 0;
 		if(buf[0]==0)
@@ -677,6 +683,18 @@ int usbcan_config_irqs(struct canchip_t *chip, short irqs)
 	return -ENOSYS;
 }
 
+
+static void usbcan_usb_message_move_list(struct usbcan_usb *dev,
+			struct usbcan_message *m, struct list_head *head)
+{
+	can_spin_irqflags_t flags;
+	can_spin_lock_irqsave(&dev->list_lock, flags);
+	list_del(&m->list_node);
+	list_add_tail(&m->list_node, head);
+	can_spin_unlock_irqrestore(&dev->list_lock, flags);
+}
+
+
 /**
  * usbcan_kthread_read_handler: - part of kthread code responsible for receive completed events
  * @dev: pointer to usb device related structure
@@ -688,44 +706,51 @@ int usbcan_config_irqs(struct canchip_t *chip, short irqs)
  * usbcan_kthread().
  * File: src/usbcan.c
  */
-void usbcan_kthread_read_handler(struct usbcan_usb *dev, struct msgobj_t *obj){
-	int i, j, len, retval;
-	CANMSG("USBCAN RX handler\n");
-	for (i=0;i<USBCAN_TOT_RX_URBS;i++){
-		if (test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&dev->rx[i].flags)){
-			CANMSG("USBCAN Thread has received a message\n");
-			if ((dev->chip)&&(dev->chip->flags & CHIP_CONFIGURED)){
-				u8 *ptr;
-				struct usbcan_message *mess=&dev->rx[i];
+void usbcan_kthread_read_handler(struct usbcan_usb *dev, struct usbcan_message *m,
+				struct msgobj_t *obj)
+{
+	int i, len, retval;
+	u8 *ptr;
 
-				len=*(u8 *)(mess->msg+1);
-				if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
-				obj->rx_msg.length = len;
+	DEBUGMSG("USBCAN RX handler\n");
 
-				obj->rx_msg.flags=le16_to_cpu(*(u16 *)(mess->msg+2));
-				obj->rx_msg.id=le32_to_cpu((*(u32 *)(mess->msg+4)));
+	if (!test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&m->flags)) {
+		CANMSG("Strange, Rx handler USBCAN_MESSAGE_DATA_OK not set\n");
+		goto skip_msg;
+	}
 
-				for(ptr=mess->msg+8,j=0; j < len; ptr++,j++) {
-					obj->rx_msg.data[j]=*ptr;
-				}
+	if (!(dev->chip)||!(dev->chip->flags & CHIP_CONFIGURED)) {
+		CANMSG("Destination chip not found\n");
+		goto skip_msg;
+	}
 
-				// fill CAN message timestamp
-				can_filltimestamp(&obj->rx_msg.timestamp);
-				canque_filter_msg2edges(obj->qends, &obj->rx_msg);
-			}
-			else
-				CANMSG("Destination chip not found\n");
-		}
-		if (!test_bit(USBCAN_MESSAGE_URB_PENDING,&dev->rx[i].flags)){
-			CANMSG("Renewing RX urb\n");
-			retval = usb_submit_urb (dev->rx[i].u, GFP_KERNEL);
-			if (retval<0){
-				CANMSG("%d. URB error %d\n", i, retval);
-				set_bit(USBCAN_ERROR,&dev->flags);
-			}
-			else
-				set_bit(USBCAN_MESSAGE_URB_PENDING,&dev->rx[i].flags);
-		}
+
+	DEBUGMSG("USBCAN Thread has received a message\n");
+
+	len=*(u8 *)(m->msg+1);
+	if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
+	obj->rx_msg.length = len;
+
+	obj->rx_msg.flags=le16_to_cpu(*(u16 *)(m->msg+2));
+	obj->rx_msg.id=le32_to_cpu((*(u32 *)(m->msg+4)));
+
+	for(ptr=m->msg+8,i=0; i < len; ptr++,i++) {
+		obj->rx_msg.data[i]=*ptr;
+	}
+
+	// fill CAN message timestamp
+	can_filltimestamp(&obj->rx_msg.timestamp);
+	canque_filter_msg2edges(obj->qends, &obj->rx_msg);
+
+skip_msg:
+	set_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+	DEBUGMSG("Renewing RX urb\n");
+
+	usbcan_usb_message_move_list(dev, m, &dev->rx_pend_list);
+	retval = usb_submit_urb (m->u, GFP_KERNEL);
+	if (retval<0) {
+		CANMSG("URB error %d\n", retval);
+		set_bit(USBCAN_ERROR,&dev->flags);
 	}
 }
 
@@ -739,36 +764,40 @@ void usbcan_kthread_read_handler(struct usbcan_usb *dev, struct msgobj_t *obj){
  * usbcan_kthread().
  * File: src/usbcan.c
  */
-void usbcan_kthread_write_handler(struct usbcan_usb *dev, struct msgobj_t *obj){
-	int i;
-	CANMSG("USBCAN TX handler\n");
-	for (i=0;i<USBCAN_TOT_TX_URBS;i++){
-		if (test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&dev->tx[i].flags)){
-			struct usbcan_message *mess=&dev->tx[i];
-			CANMSG("USBCAN Message successfully sent\n");
-
-			if(mess->slot){
-				// Do local transmitted message distribution if enabled
-				if (processlocal){
-					// fill CAN message timestamp
-					can_filltimestamp(&mess->slot->msg.timestamp);
-
-					mess->slot->msg.flags |= MSG_LOCAL;
-					canque_filter_msg2edges(obj->qends, &mess->slot->msg);
-				}
-				// Free transmitted slot
-				canque_free_outslot(obj->qends, mess->qedge, mess->slot);
-				mess->slot=NULL;
-			}
-			can_msgobj_clear_fl(obj,TX_PENDING);
+void usbcan_kthread_write_handler(struct usbcan_usb *dev, struct usbcan_message *m,
+				struct msgobj_t *obj)
+{
+	if (!test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&m->flags)) {
+		CANMSG("Strange, Tx handler USBCAN_MESSAGE_DATA_OK not set\n");
+		goto skip_msg;
+	}
 
-			set_bit(USBCAN_FREE_TX_URB,&dev->flags);
-			set_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
+	DEBUGMSG("USBCAN Message successfully sent\n");
 
-			// Test if some new messages arrived
-			set_bit(USBCAN_TX_PENDING,&dev->flags);
+	if(m->slot){
+		// Do local transmitted message distribution if enabled
+		if (processlocal){
+			// fill CAN message timestamp
+			can_filltimestamp(&m->slot->msg.timestamp);
+
+			m->slot->msg.flags |= MSG_LOCAL;
+			canque_filter_msg2edges(obj->qends, &m->slot->msg);
 		}
+		// Free transmitted slot
+		canque_free_outslot(obj->qends, m->qedge, m->slot);
+		m->slot=NULL;
 	}
+	
+	/*FIXME - why there*/
+	can_msgobj_clear_fl(obj,TX_PENDING);
+
+skip_msg:
+	set_bit(USBCAN_FREE_TX_URB,&dev->flags);
+	set_bit(USBCAN_MESSAGE_FREE,&m->flags);
+
+	set_bit(USBCAN_TX_PENDING,&dev->flags);
+
+	usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
 }
 
 /**
@@ -783,52 +812,60 @@ void usbcan_kthread_write_handler(struct usbcan_usb *dev, struct msgobj_t *obj){
  * File: src/usbcan.c
  */
 void usbcan_kthread_write_request_handler(struct usbcan_usb *dev, struct msgobj_t *obj){
-	int i, j, cmd, len, retval;
-	for (i=0;i<USBCAN_TOT_TX_URBS;i++){
-		if (test_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags)){
-			struct usbcan_message *mess=&dev->tx[i];
-			u8 *ptr;
-			cmd=canque_test_outslot(obj->qends, &mess->qedge, &mess->slot);
-			if(cmd>=0){
-				CANMSG("USBCAN Sending a message\n");
-
-				can_msgobj_set_fl(obj,TX_PENDING);
-				clear_bit(USBCAN_FREE_TX_URB,&dev->flags);
-				clear_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
-
-				*(u8 *)(mess->msg)=0;
-				len = mess->slot->msg.length;
-				if(len > CAN_MSG_LENGTH)
-					len = CAN_MSG_LENGTH;
-				*(u8 *)(mess->msg+1)=len & 0xFF;
-				*(u16 *)(mess->msg+2)=cpu_to_le16(mess->slot->msg.flags);
-				*(u32 *)(mess->msg+4)=cpu_to_le32(mess->slot->msg.id);
-
-				for(ptr=mess->msg+8,j=0; j < len; ptr++,j++) {
-					*ptr=mess->slot->msg.data[j] & 0xFF;
-				}
-				for(; j < 8; ptr++,j++) {
-					*ptr=0;
-				}
+	int i, cmd, len, retval;
+	u8 *ptr;
+	struct usbcan_message *m;
 
-				set_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
-				retval = usb_submit_urb (dev->tx[i].u, GFP_KERNEL);
-				if (retval){
-					CANMSG("%d. URB error %d\n",i,retval);
-					clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
-					set_bit(USBCAN_FREE_TX_URB,&dev->flags);
-					set_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
-					obj->ret = -1;
-					canque_notify_inends(mess->qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
-					canque_free_outslot(obj->qends, mess->qedge, mess->slot);
-					mess->slot=NULL;
-				}
-			}
-			else{
-				set_bit(USBCAN_FREE_TX_URB,&dev->flags);
-				break;
-			}
+	if(list_empty(&dev->tx_idle_list)) {
+		clear_bit(USBCAN_FREE_TX_URB,&dev->flags);
+		return;
+	}
+	
+	m = list_first_entry(&dev->tx_idle_list, typeof(*m), list_node);
+
+	cmd=canque_test_outslot(obj->qends, &m->qedge, &m->slot);
+	if(cmd>=0){
+		DEBUGMSG("USBCAN Sending a message\n");
+
+		can_msgobj_set_fl(obj,TX_PENDING);
+		clear_bit(USBCAN_FREE_TX_URB,&dev->flags);
+		clear_bit(USBCAN_MESSAGE_FREE,&m->flags);
+
+		*(u8 *)(m->msg)=0;
+		len = m->slot->msg.length;
+		if(len > CAN_MSG_LENGTH)
+		len = CAN_MSG_LENGTH;
+		*(u8 *)(m->msg+1)=len & 0xFF;
+		*(u16 *)(m->msg+2)=cpu_to_le16(m->slot->msg.flags);
+		*(u32 *)(m->msg+4)=cpu_to_le32(m->slot->msg.id);
+
+		for(ptr=m->msg+8, i=0; i < len; ptr++,i++) {
+			*ptr=m->slot->msg.data[i] & 0xFF;
+		}
+		for(; i < 8; ptr++,i++) {
+			*ptr=0;
+		}
+
+		set_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+
+		usbcan_usb_message_move_list(dev, m, &dev->tx_pend_list);
+
+		retval = usb_submit_urb (m->u, GFP_KERNEL);
+		if (retval){
+			CANMSG("%d. URB error %d\n",i,retval);
+			clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+			set_bit(USBCAN_FREE_TX_URB,&dev->flags);
+			set_bit(USBCAN_MESSAGE_FREE,&m->flags);
+			obj->ret = -1;
+			canque_notify_inends(m->qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
+			canque_free_outslot(obj->qends, m->qedge, m->slot);
+			m->slot=NULL;
+			usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
+		} else {
+			set_bit(USBCAN_TX_PENDING,&dev->flags);
 		}
+	} else {
+		set_bit(USBCAN_FREE_TX_URB,&dev->flags);
 	}
 }
 
@@ -866,7 +903,7 @@ int usbcan_wakeup_tx(struct canchip_t *chip, struct msgobj_t *obj)
 {
 	struct usbcan_usb *dev=(struct usbcan_usb *)chip->chip_data;
 
-	CANMSG("Trying to send message\n");
+	DEBUGMSG("Trying to send message\n");
 	can_preempt_disable();
 
 	can_msgobj_set_fl(obj,TX_PENDING);
@@ -1010,44 +1047,90 @@ static int usbcan_sleep_thread(struct usbcan_usb *dev)
 	return rc;
 }
 
-static void usbcan_callback(struct urb *urb)
+static void usbcan_tx_callback(struct urb *urb)
 {
-	struct usbcan_message *mess = urb->context;
+	struct usbcan_message *m = urb->context;
 	int retval;
 
-	if (!test_bit(USBCAN_THREAD_RUNNING,&mess->dev->flags))
+	if (!test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
 		return;
-	if (test_bit(USBCAN_MESSAGE_TERMINATE,&mess->flags))
+	if (test_bit(USBCAN_MESSAGE_TERMINATE,&m->flags))
 		return;
 
 	switch (urb->status) {
 	case 0:
 		/* success */
-		CANMSG("%s > Message OK\n", __FUNCTION__);
-		set_bit(USBCAN_DATA_OK,&mess->dev->flags);
-		set_bit(USBCAN_MESSAGE_DATA_OK,&mess->flags);
-		if (test_bit(USBCAN_MESSAGE_TYPE_RX,&mess->flags)){
-			CANMSG("%s > RX flag set\n", __FUNCTION__);
-			set_bit(USBCAN_DATA_RX,&mess->dev->flags);
-		}
-		if (test_bit(USBCAN_MESSAGE_TYPE_TX,&mess->flags))
-			CANMSG("%s > TX flag set\n", __FUNCTION__);
-			set_bit(USBCAN_DATA_TX,&mess->dev->flags);
-		clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
-		if (test_bit(USBCAN_THREAD_RUNNING,&mess->dev->flags))
-			wake_up_process(mess->dev->comthread);
+		DEBUGMSG("%s > Message OK\n", __FUNCTION__);
+		set_bit(USBCAN_DATA_OK,&m->dev->flags);
+		set_bit(USBCAN_MESSAGE_DATA_OK,&m->flags);
+		DEBUGMSG("%s > TX flag set\n", __FUNCTION__);
+		set_bit(USBCAN_DATA_TX,&m->dev->flags);
+		clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+		usbcan_usb_message_move_list(m->dev, m, &m->dev->tx_ready_list);
+		if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+			wake_up_process(m->dev->comthread);
+		else
+			CANMSG("%s > USBCAN thread not running\n", __FUNCTION__);
+		return;
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* this urb is terminated, clean up */
+		CANMSG("%s > Urb shutting down with status: %d\n", __FUNCTION__, urb->status);
+		set_bit(USBCAN_TERMINATE,&m->dev->flags);
+		set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+		clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+		return;
+	default:
+		//CANMSG("%s > Nonzero status received: %d\n", __FUNCTION__, urb->status);
+		break;
+	}
+
+	// Try to send urb again on non significant errors
+	retval = usb_submit_urb (urb, GFP_ATOMIC);
+	if (retval<0){
+		CANMSG("%s > Retrying urb failed with result %d\n", __FUNCTION__, retval);
+		set_bit(USBCAN_ERROR,&m->dev->flags);
+		clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+		usbcan_usb_message_move_list(m->dev, m, &m->dev->tx_ready_list);
+		if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+			wake_up_process(m->dev->comthread);
+	}
+}
+
+static void usbcan_rx_callback(struct urb *urb)
+{
+	struct usbcan_message *m = urb->context;
+	int retval;
+
+	if (!test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+		return;
+	if (test_bit(USBCAN_MESSAGE_TERMINATE,&m->flags))
+		return;
+
+	switch (urb->status) {
+	case 0:
+		/* success */
+		DEBUGMSG("%s > Message OK\n", __FUNCTION__);
+		set_bit(USBCAN_DATA_OK,&m->dev->flags);
+		set_bit(USBCAN_MESSAGE_DATA_OK,&m->flags);
+		DEBUGMSG("%s > RX flag set\n", __FUNCTION__);
+		set_bit(USBCAN_DATA_RX,&m->dev->flags);
+		clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+		usbcan_usb_message_move_list(m->dev, m, &m->dev->rx_ready_list);
+		if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+			wake_up_process(m->dev->comthread);
 		else
 			CANMSG("%s > USBCAN thread not running\n", __FUNCTION__);
-// 			wake_up(&mess->dev->queue);
 		return;
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 		/* this urb is terminated, clean up */
 		CANMSG("%s > Urb shutting down with status: %d\n", __FUNCTION__, urb->status);
-		set_bit(USBCAN_TERMINATE,&mess->dev->flags);
-		set_bit(USBCAN_MESSAGE_TERMINATE,&mess->flags);
-		clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
+		set_bit(USBCAN_TERMINATE,&m->dev->flags);
+		set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+		clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
 		return;
 	default:
 		//CANMSG("%s > Nonzero status received: %d\n", __FUNCTION__, urb->status);
@@ -1058,12 +1141,57 @@ static void usbcan_callback(struct urb *urb)
 	retval = usb_submit_urb (urb, GFP_ATOMIC);
 	if (retval<0){
 		CANMSG("%s > Retrying urb failed with result %d\n", __FUNCTION__, retval);
-		set_bit(USBCAN_ERROR,&mess->dev->flags);
-		clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
-		if (test_bit(USBCAN_THREAD_RUNNING,&mess->dev->flags))
-			wake_up_process(mess->dev->comthread);
-// 			wake_up(&mess->dev->queue);
+		set_bit(USBCAN_ERROR,&m->dev->flags);
+		clear_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+		usbcan_usb_message_move_list(m->dev, m, &m->dev->rx_ready_list);
+		if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+			wake_up_process(m->dev->comthread);
+	}
+}
+
+
+static void usbcan_kthread_free_urbs(struct usbcan_usb *dev)
+{
+	while(!list_empty(&dev->rx_pend_list)) {
+		struct usbcan_message *m;
+		m = list_first_entry(&dev->rx_pend_list, typeof(*m), list_node);
+		set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+		usb_kill_urb(m->u);
+		usbcan_usb_message_move_list(dev, m, &dev->rx_ready_list);
+	}
+
+	while(!list_empty(&dev->tx_pend_list)) {
+		struct usbcan_message *m;
+		m = list_first_entry(&dev->tx_pend_list, typeof(*m), list_node);
+		set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+		usb_kill_urb(m->u);
+		usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
+	}
+
+	while(!list_empty(&dev->rx_ready_list)) {
+		struct usbcan_message *m;
+		m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
+		list_del(&m->list_node);
+		usb_free_urb(m->u);
+		kfree(m);
+	}
+
+	while(!list_empty(&dev->tx_ready_list)) {
+		struct usbcan_message *m;
+		m = list_first_entry(&dev->tx_ready_list, typeof(*m), list_node);
+		list_del(&m->list_node);
+		usb_free_urb(m->u);
+		kfree(m);
+	}
+
+	while(!list_empty(&dev->tx_idle_list)) {
+		struct usbcan_message *m;
+		m = list_first_entry(&dev->tx_idle_list, typeof(*m), list_node);
+		list_del(&m->list_node);
+		usb_free_urb(m->u);
+		kfree(m);
 	}
+
 }
 
 int usbcan_kthread(void *data)
@@ -1072,61 +1200,90 @@ int usbcan_kthread(void *data)
  	struct usbcan_usb *dev=(struct usbcan_usb *)data;
 	struct msgobj_t *obj;
 
-  CANMSG("Usbcan thread started...\n");
+	CANMSG("Usbcan thread started...\n");
 
 	if (!dev->chip)
 		goto error;
 	obj=dev->chip->msgobj[0];
 
+
+	INIT_LIST_HEAD(&dev->rx_pend_list);
+	INIT_LIST_HEAD(&dev->rx_ready_list);
+	INIT_LIST_HEAD(&dev->tx_idle_list);
+	INIT_LIST_HEAD(&dev->tx_pend_list);
+	INIT_LIST_HEAD(&dev->tx_ready_list);
+
 	/* Prepare receive urbs  */
 	for (i=0;i<USBCAN_TOT_RX_URBS;i++){
-		dev->rx[i].u = usb_alloc_urb(0, GFP_KERNEL);
-		if (!dev->rx[i].u){
+		struct usbcan_message *m;
+		struct urb *u = usb_alloc_urb(0, GFP_KERNEL);
+		if (!u){
 			CANMSG("Error allocating %d. usb receive urb\n",i);
 			goto error;
 		}
-		dev->rx[i].u->dev = dev->udev;
-		dev->rx[i].dev = dev;
-		usb_fill_bulk_urb(dev->rx[i].u, dev->udev,
-				usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
-				dev->rx[i].msg, USBCAN_TRANSFER_SIZE,
-				usbcan_callback, &dev->rx[i]);
-		set_bit(USBCAN_MESSAGE_TYPE_RX,&dev->rx[i].flags);
+		m = kmalloc(sizeof(struct usbcan_message), GFP_KERNEL);
+		if(!m) {
+			usb_free_urb(u);
+			CANMSG("Error allocating %d. receive usbcan_message\n",i);
+			goto error;
+		}
+		m->u = u;
+		u->dev = dev->udev;
+		m->dev = dev;
+		usb_fill_bulk_urb(u, dev->udev,
+			usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
+			m->msg, USBCAN_TRANSFER_SIZE, usbcan_rx_callback, m);
+		set_bit(USBCAN_MESSAGE_TYPE_RX, &m->flags);
+		list_add_tail(&m->list_node, &dev->rx_ready_list);
 	}
 
 	/* Prepare transmit urbs  */
 	for (i=0;i<USBCAN_TOT_TX_URBS;i++){
-		dev->tx[i].u = usb_alloc_urb(0, GFP_KERNEL);
-		if (!dev->tx[i].u){
+		struct usbcan_message *m;
+		struct urb *u = usb_alloc_urb(0, GFP_KERNEL);
+		if (!u){
 			CANMSG("Error allocating %d. usb transmit urb\n",i);
 			goto error;
 		}
-		dev->tx[i].u->dev = dev->udev;
-		dev->tx[i].dev = dev;
-		usb_fill_bulk_urb(dev->tx[i].u, dev->udev,
-				usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
-				dev->tx[i].msg, USBCAN_TRANSFER_SIZE,
-				usbcan_callback, &dev->tx[i]);
-		set_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
-		set_bit(USBCAN_MESSAGE_TYPE_TX,&dev->tx[i].flags);
+		m = kmalloc(sizeof(struct usbcan_message), GFP_KERNEL);
+		if(!m) {
+			usb_free_urb(u);
+			CANMSG("Error allocating %d. transmit usbcan_message\n",i);
+			goto error;
+		}
+		m->u = u;
+		u->dev = dev->udev;
+		m->dev = dev;
+		usb_fill_bulk_urb(u, dev->udev,
+			usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
+			m->msg, USBCAN_TRANSFER_SIZE, usbcan_tx_callback, m);
+			
+		set_bit(USBCAN_MESSAGE_FREE,&m->flags);
+		set_bit(USBCAN_MESSAGE_TYPE_TX,&m->flags);
+		list_add_tail(&m->list_node, &dev->tx_idle_list);
+
 	}
 
 	set_bit(USBCAN_THREAD_RUNNING,&dev->flags);
 	set_bit(USBCAN_FREE_TX_URB,&dev->flags);
 
 	for (i=0;i<USBCAN_TOT_RX_URBS;i++){
-		retval=usb_submit_urb(dev->rx[i].u, GFP_KERNEL);
+		struct usbcan_message *m;
+		m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
+		set_bit(USBCAN_MESSAGE_URB_PENDING,&m->flags);
+		usbcan_usb_message_move_list(dev, m, &dev->rx_pend_list);
+
+		retval=usb_submit_urb(m->u, GFP_KERNEL);
 		if (retval){
 			CANMSG("%d. URB error %d\n",i,retval);
 			set_bit(USBCAN_ERROR,&dev->flags);
+			usbcan_usb_message_move_list(dev, m, &dev->rx_ready_list);
 			goto exit;
 		}
-		else
-			set_bit(USBCAN_MESSAGE_URB_PENDING,&dev->rx[i].flags);
 	}
-  /* an endless loop in which we are doing our work */
-  for(;;)
-  {
+	/* an endless loop in which we are doing our work */
+	for(;;)
+	{
 		/* We need to do a memory barrier here to be sure that
 		the flags are visible on all CPUs. */
 		mb();
@@ -1158,47 +1315,40 @@ int usbcan_kthread(void *data)
 			break;
 		}
 
-		{ /* Normal work to do */
-			if (test_and_clear_bit(USBCAN_DATA_OK,&dev->flags)){
-				CANMSG("USBCAN Succesfull data transfer\n");
+		while(!list_empty(&dev->rx_ready_list)) {
+			struct usbcan_message *m;
+			m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
+			usbcan_kthread_read_handler(dev, m, obj);
+		}
 
-				if (test_and_clear_bit(USBCAN_DATA_RX,&dev->flags)){
-					usbcan_kthread_read_handler(dev, obj);
-				}
-				if (test_and_clear_bit(USBCAN_DATA_TX,&dev->flags)){
-					usbcan_kthread_write_handler(dev, obj);
-				}
-			}
-			if (test_and_clear_bit(USBCAN_TX_PENDING,&dev->flags)){
-				usbcan_kthread_write_request_handler(dev, obj);
-			}
-    }
-  }
-	set_bit(USBCAN_TERMINATE,&dev->flags);
-exit:
-  /* here we go only in case of termination of the thread */
-	for (i=0;i<USBCAN_TOT_RX_URBS;i++){
-		if (dev->rx[i].u){
-			set_bit(USBCAN_MESSAGE_TERMINATE,&dev->rx[i].flags);
-			usb_kill_urb(dev->rx[i].u);
-			usb_free_urb(dev->rx[i].u);
+		while(!list_empty(&dev->tx_ready_list)) {
+			struct usbcan_message *m;
+			m = list_first_entry(&dev->tx_ready_list, typeof(*m), list_node);
+			usbcan_kthread_write_handler(dev, m, obj);
 		}
-	}
-	for (i=0;i<USBCAN_TOT_TX_URBS;i++){
-		if (dev->tx[i].u){
-			set_bit(USBCAN_MESSAGE_TERMINATE,&dev->tx[i].flags);
-			usb_kill_urb(dev->tx[i].u);
-			usb_free_urb(dev->tx[i].u);
+
+		if (test_and_clear_bit(USBCAN_TX_PENDING,&dev->flags)) {
+			usbcan_kthread_write_request_handler(dev, obj);
 		}
 	}
+
+	set_bit(USBCAN_TERMINATE,&dev->flags);
+exit:
+  /* here we go only in case of termination of the thread */
+
+	usbcan_kthread_free_urbs(dev);
+
+
 	clear_bit(USBCAN_THREAD_RUNNING,&dev->flags);
 
-  CANMSG ("usbcan thread finished!\n");
-  return 0;
+ 	CANMSG ("usbcan thread finished!\n");
+	return 0;
 error:
-  /* cleanup the thread, leave */
-  CANMSG ("kernel thread terminated!\n");
-  return -ENOMEM;
+	/* cleanup the thread, leave */
+	usbcan_kthread_free_urbs(dev);
+
+	CANMSG ("kernel thread terminated!\n");
+	return -ENOMEM;
 }
 
 static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id)
@@ -1212,7 +1362,7 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
 
 	iface_desc = interface->cur_altsetting;
 	if (iface_desc->desc.bNumEndpoints % 2){
-		err("Endpoint count must be even");
+		CANMSG("Endpoint count must be even");
 		goto noalloc;
 	}
 
@@ -1220,7 +1370,7 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
 
 	usbdevs = (struct usbcan_devs *) can_checked_malloc(sizeof(struct usbcan_devs));
 	if (!usbdevs) {
-		err("Out of memory");
+		CANMSG("Out of memory");
 		goto error;
 	}
 	memset(usbdevs, 0, sizeof(struct usbcan_devs));
@@ -1229,7 +1379,7 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
 
 	usbdevs->devs = (struct usbcan_usb **) can_checked_malloc(usbcan_chip_count * sizeof(struct usbcan_usb *));
 	if (!usbdevs->devs) {
-		err("Out of memory");
+		CANMSG("Out of memory");
 		goto error;
 	}
 	memset(usbdevs->devs, 0, usbcan_chip_count * sizeof(struct usbcan_usb *));
@@ -1241,11 +1391,12 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
 		/* allocate memory for our device state and initialize it */
 		usbdevs->devs[j] = (struct usbcan_usb *) can_checked_malloc(sizeof(struct usbcan_usb));
 		if (!usbdevs->devs[j]) {
-			err("Out of memory");
+			CANMSG("Out of memory");
 			goto error;
 		}
 		memset(usbdevs->devs[j], 0, sizeof(struct usbcan_usb));
 		dev=usbdevs->devs[j];
+		spin_lock_init(&usbdevs->devs[j]->list_lock);
 
 		mutex_init(&dev->io_mutex);
 		init_waitqueue_head(&dev->queue);
@@ -1275,7 +1426,7 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
 					dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
 					dev->bulk_in_buffer = can_checked_malloc(buffer_size);
 					if (!dev->bulk_in_buffer) {
-						err("Could not allocate bulk_in_buffer");
+						CANMSG("Could not allocate bulk_in_buffer");
 						goto error;
 					}
 				}
@@ -1291,7 +1442,7 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
 
 		}
 		if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
-			err("Could not find all bulk-in and bulk-out endpoints for chip %d",j);
+			CANMSG("Could not find all bulk-in and bulk-out endpoints for chip %d",j);
 			goto error;
 		}
 	}