X-Git-Url: http://rtime.felk.cvut.cz/gitweb/lincan.git/blobdiff_plain/102b0fcc467c77d0a8f82cfee060353e3cf17261..c6d6f58c34e1b6a4c03d1e86d1abf48eeb6f5624:/lincan/src/setup.c

diff --git a/lincan/src/setup.c b/lincan/src/setup.c
index 49b4315..57883ce 100644
--- a/lincan/src/setup.c
+++ b/lincan/src/setup.c
@@ -7,23 +7,12 @@
  * Version lincan-0.2  9 Jul 2003
  */ 
 
-#define __NO_VERSION__
-#include <linux/module.h>
-
-#include <linux/autoconf.h>
-
-#include <linux/version.h>
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
-#include <linux/malloc.h>
-#else
-#include <linux/slab.h>
-#endif
-#include <linux/fs.h>
-#include <linux/ioport.h>
-
+#include "../include/can.h"
+#include "../include/can_sysdep.h"
 #include "../include/main.h"
 #include "../include/devcommon.h"
 #include "../include/setup.h"
+#include "../include/finish.h"
 
 extern int sja1000_register(struct chipspecops_t *chipspecops);
 extern int sja1000p_register(struct chipspecops_t *chipspecops);
@@ -35,79 +24,79 @@ int init_chip_struct(struct candevice_t *candev);
 int init_obj_struct(struct candevice_t *candev, struct chip_t *hostchip, int minorbase);
 int init_chipspecops(struct candevice_t *candev, int chipnr);
 
-int add_mem_to_list(void *address_p)
+void *can_checked_malloc(size_t size)
 {
 	struct mem_addr *mem_new;
+	void *address_p;
+	
+	address_p=kmalloc(size,GFP_KERNEL);
+	if(address_p == NULL) {
+		CANMSG("can_checked_malloc: out of the memory\n");
+		return NULL;
+	}
 
 #ifdef DEBUG_MEM
-	DEBUGMSG("add_mem_to_list %p, mem_head=%p\n",address_p, mem_head);
-	return 0;
+	DEBUGMSG("can_checked_malloc: allocated %d bytes at %p, mem_head=%p\n",
+			(int)size, address_p, mem_head);
 #endif
 
 	mem_new=(struct mem_addr *)kmalloc(sizeof(struct mem_addr),GFP_KERNEL);
 	if (mem_new == NULL) {
-		CANMSG("Memory list error.\n");
-		return -ENOMEM;
+		CANMSG("can_checked_malloc: memory list allocation error.\n");
+		kfree(address_p);
+		return NULL;
 	}
 	mem_new->next=mem_head;
 	mem_new->address=address_p;
+	mem_new->size=size;
 	mem_head=mem_new;
 
-	return 0;
+	return address_p;
 }
 
-int del_mem_from_list(void *address_p)
+int can_checked_free(void *address_p)
 {
-	struct mem_addr *mem_search=NULL;
-	struct mem_addr *mem_delete=NULL;
+	struct mem_addr **mem_pptr;
+	struct mem_addr *mem_del=NULL;
 
 #ifdef DEBUG_MEM
-	DEBUGMSG("del_mem_from_list %p, mem_head=%p\n", address_p, mem_head);
-	return 0;
+	DEBUGMSG("can_checked_free %p, mem_head=%p\n", address_p, mem_head);
 #endif
-	if(mem_head == NULL) {
-		CANMSG("del_mem_from_list: mem_head == NULL address_p=%p!\n",
-				address_p);
-		return 0;
-	}
-
-	mem_search = mem_head;
 
-	if (mem_head->address == address_p) {
-		kfree(mem_head->address);
-		mem_head=mem_head->next;
-		kfree(mem_search);
-	}
-	else {
-		while (mem_search->next->address != address_p)
-			mem_search=mem_search->next;
-		kfree(mem_search->next->address);		
-		mem_delete=mem_search->next;
-		mem_search->next=mem_search->next->next;
-		kfree(mem_delete);
+	for(mem_pptr = &mem_head; (mem_del = *mem_pptr); mem_pptr = &mem_del->next) {
+		if (mem_del->address != address_p)
+			continue;
+		*mem_pptr=mem_del->next;
+		kfree(mem_del);
+		kfree(address_p);
+		return 0;
 	}
-	return 0;
+	
+	CANMSG("can_checked_free: address %p not found on the mem list\n", address_p);
+	
+	kfree(address_p);
+	return -1;
 }
 
 
-int del_mem_list(void)
+int can_del_mem_list(void)
 {
-	struct mem_addr *mem_old;
+	struct mem_addr *mem;
 
 #ifdef DEBUG_MEM
-	DEBUGMSG("del_mem_list, mem_head=%p\n", mem_head);
-	return 0;
+	DEBUGMSG("can_del_mem_list, mem_head=%p\n", mem_head);
 #endif
 	if(mem_head == NULL) {
-		CANMSG("del_mem_list: mem_head == NULL!\n");
+		CANMSG("can_del_mem_list: no entries on the list - OK\n");
 		return 0;
 	}
 
-	while (mem_head->next != NULL) {
-		mem_old=mem_head;
-		kfree(mem_old->address);
-		mem_head=mem_old->next;
-		kfree(mem_old);
+	while((mem=mem_head) != NULL) {
+		mem_head=mem->next;
+		CANMSG("can_del_mem_list: deleting %p with size %d\n",
+			mem->address, (int)mem->size);
+		kfree(mem->address);
+		kfree(mem);
 	}
 	
 	return 0;
@@ -189,13 +178,11 @@ int init_hw_struct(void)
 int init_device_struct(int card)
 {
 	struct candevice_t *candev;
+	int ret;
 	
-	candev=(struct candevice_t *)kmalloc(sizeof(struct candevice_t),GFP_KERNEL);
+	candev=(struct candevice_t *)can_checked_malloc(sizeof(struct candevice_t));
 	if (candev==NULL)
 		return -ENOMEM;
-	else
-		if ( add_mem_to_list(candev) )
-			return -ENOMEM;
 
         memset(candev, 0, sizeof(struct candevice_t));
 
@@ -208,24 +195,36 @@ int init_device_struct(int card)
 	candev->io_addr=io[card];
 	candev->dev_base_addr=io[card];
 
-	candev->hwspecops=(struct hwspecops_t *)kmalloc(sizeof(struct hwspecops_t),GFP_KERNEL);
+	candev->hwspecops=(struct hwspecops_t *)can_checked_malloc(sizeof(struct hwspecops_t));
 	if (candev->hwspecops==NULL)
-		return -ENOMEM;
-	else
-		if ( add_mem_to_list(candev->hwspecops) )
-			return -ENOMEM;
+		goto error_nomem;
+
 	memset(candev->hwspecops, 0, sizeof(struct hwspecops_t));
 
 	if (init_hwspecops(candev))
-		return -ENODEV;
+		goto error_nodev;
 
 	if (candev->hwspecops->init_hw_data(candev))
-		return -ENODEV;
+		goto error_nodev;
 
 	if (init_chip_struct(candev))
-		return -ENODEV;
+		goto error_nodev;
 
 	return 0;
+
+    error_nodev:
+	candevice_done(candev);
+	ret=-ENODEV;
+	goto error_both;
+
+    error_nomem:
+	ret=-ENOMEM;
+
+    error_both:
+	hardware_p->candevice[card]=NULL;
+	can_checked_free(candev);
+	return ret;
+    	
 }
 
 /* The function init_chip_struct is used to initialize all chip_t structures
@@ -238,29 +237,26 @@ int init_chip_struct(struct candevice_t *candev)
 
 	/* Alocate and initialize the chip structures */
 	for (i=0; i < candev->nr_all_chips; i++) {
-		candev->chip[i]=(struct chip_t *)kmalloc(sizeof(struct chip_t),GFP_KERNEL);
+		candev->chip[i]=(struct chip_t *)can_checked_malloc(sizeof(struct chip_t));
 		if (candev->chip[i]==NULL)
 			return -ENOMEM;
-		else
-			if ( add_mem_to_list(candev->chip[i]) )
-				return -ENOMEM;
 
         	memset(candev->chip[i], 0, sizeof(struct chip_t));
 		
 		candev->chip[i]->write_register=candev->hwspecops->write_register;
 		candev->chip[i]->read_register=candev->hwspecops->read_register;
 
-		candev->chip[i]->chipspecops=(struct chipspecops_t *)kmalloc(sizeof(struct chipspecops_t),GFP_KERNEL);
+		candev->chip[i]->chipspecops=can_checked_malloc(sizeof(struct chipspecops_t));
 		if (candev->chip[i]->chipspecops==NULL)
 			return -ENOMEM;
-		else
-			if ( add_mem_to_list(candev->chip[i]->chipspecops) )
-				return -ENOMEM;
 
-		chips_p[irq_count]=candev->chip[i];
+                chips_p[irq_count]=candev->chip[i];
 		candev->chip[i]->chip_idx=i;
 		candev->chip[i]->hostdevice=candev;
 		candev->chip[i]->chip_irq=irq[irq_count];
+		candev->chip[i]->baudrate=baudrate[irq_count]*1000;
+		if(!candev->chip[i]->baudrate)
+			candev->chip[i]->baudrate=baudrate[0]*1000;
 		candev->chip[i]->flags=0x0;
 
 		candev->hwspecops->init_chip_data(candev,i);
@@ -285,21 +281,19 @@ int init_obj_struct(struct candevice_t *candev, struct chip_t *hostchip, int min
 
 	max_objects=hostchip->max_objects;
 	for (i=0; i<max_objects; i++) {
-		obj=(struct msgobj_t *)kmalloc(sizeof(struct msgobj_t),GFP_KERNEL);
+		obj=(struct msgobj_t *)can_checked_malloc(sizeof(struct msgobj_t));
 		hostchip->msgobj[i]=obj;
 		if (obj == NULL) 
 			return -ENOMEM;
-		else
-			if ( add_mem_to_list(obj) )
-				return -ENOMEM;
-
+			
         	memset(obj, 0, sizeof(struct msgobj_t));
 
 		atomic_set(&obj->obj_used,0);
 		INIT_LIST_HEAD(&obj->obj_users);
-		qends = (struct canque_ends_t *)kmalloc(sizeof(struct canque_ends_t), GFP_KERNEL);
+		init_timer(&obj->tx_timeout);
+		
+		qends = (struct canque_ends_t *)can_checked_malloc(sizeof(struct canque_ends_t));
 		if(qends == NULL) return -ENOMEM;
-		if(add_mem_to_list(qends)) return -ENOMEM;
 		memset(qends, 0, sizeof(struct canque_ends_t));
 		obj->hostchip=hostchip;
 		obj->object=i+1;