X-Git-Url: http://rtime.felk.cvut.cz/gitweb/lincan.git/blobdiff_plain/11132ea490f9e860744ee4f851c67e7fb4444231..b34a548a5dfd2f0b068fd835a4cd51680d851068:/lincan/src/setup.c?ds=sidebyside

diff --git a/lincan/src/setup.c b/lincan/src/setup.c
index d234eb9..acc7cac 100644
--- a/lincan/src/setup.c
+++ b/lincan/src/setup.c
@@ -7,55 +7,16 @@
  * 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 ".supported_cards.h"
-
+#include "../include/can.h"
+#include "../include/can_sysdep.h"
 #include "../include/main.h"
 #include "../include/devcommon.h"
 #include "../include/setup.h"
-#include "../include/pip.h"
-#include "../include/pccan.h"
-#include "../include/smartcan.h"
-#include "../include/pc-i03.h"
-#include "../include/pcm3680.h"
-#include "../include/m437.h"
-#include "../include/template.h"
-#include "../include/i82527.h"
-#include "../include/aim104.h"
-#include "../include/pcccan.h"
+#include "../include/finish.h"
 
 extern int sja1000_register(struct chipspecops_t *chipspecops);
 extern int sja1000p_register(struct chipspecops_t *chipspecops);
 extern int i82527_register(struct chipspecops_t *chipspecops);
-extern int template_register(struct hwspecops_t *hwspecops);
-extern int pip5_register(struct hwspecops_t *hwspecops);
-extern int pip6_register(struct hwspecops_t *hwspecops);
-extern int smartcan_register(struct hwspecops_t *hwspecops);
-extern int pccanf_register(struct hwspecops_t *hwspecops);
-extern int pccand_register(struct hwspecops_t *hwspecops);
-extern int pccanq_register(struct hwspecops_t *hwspecops);
-extern int nsi_register(struct hwspecops_t *hwspecops);
-extern int cc104_register(struct hwspecops_t *hwspecops);
-extern int pci03_register(struct hwspecops_t *hwspecops);
-extern int pcm3680_register(struct hwspecops_t *hwspecops);
-extern int aim104_register(struct hwspecops_t *hwspecops);
-extern int pcccan_register(struct hwspecops_t *hwspecops);
-extern int ssv_register(struct hwspecops_t *hwspecops);
-extern int bfadcan_register(struct hwspecops_t *hwspecops);
-extern int pikronisa_register(struct hwspecops_t *hwspecops);
 
 int init_device_struct(int card);
 int init_hwspecops(struct candevice_t *candev);
@@ -63,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;
@@ -157,6 +118,24 @@ void can_release_io_region(unsigned long start, unsigned long n)
 	release_region(start,n);
 }
 
+int can_request_mem_region(unsigned long start, unsigned long n, const char *name)
+{
+    #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
+	return 1;
+    #else
+	return (request_mem_region(start,n,name))?1:0;
+    #endif
+}
+
+void can_release_mem_region(unsigned long start, unsigned long n)
+{
+    #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
+	return;
+    #else
+	release_mem_region(start,n);
+    #endif
+}
+
 /* This function shifts all base address structures acording to address
    translation between physical and virtual address mappings */
 int can_base_addr_fixup(struct candevice_t *candev, unsigned long new_base)
@@ -199,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));
 
@@ -218,23 +195,37 @@ 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;
+	if ((ret=init_chip_struct(candev)))
+		goto error_chip;
 
 	return 0;
+
+    error_nodev:
+	ret=-ENODEV;
+    error_chip:
+	candevice_done(candev);
+	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
@@ -242,42 +233,40 @@ int init_device_struct(int card)
  */
 int init_chip_struct(struct candevice_t *candev)
 {
+	struct chip_t *chip;
 	static int irq_count=0;
 	int i=0;
 
 	/* 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);
-		if (candev->chip[i]==NULL)
+		candev->chip[i]=(struct chip_t *)can_checked_malloc(sizeof(struct chip_t));
+		if ((chip=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));
+        	memset(chip, 0, sizeof(struct chip_t));
 		
-		candev->chip[i]->write_register=candev->hwspecops->write_register;
-		candev->chip[i]->read_register=candev->hwspecops->read_register;
+		chip->write_register=candev->hwspecops->write_register;
+		chip->read_register=candev->hwspecops->read_register;
 
-		candev->chip[i]->chipspecops=(struct chipspecops_t *)kmalloc(sizeof(struct chipspecops_t),GFP_KERNEL);
-		if (candev->chip[i]->chipspecops==NULL)
+		chip->chipspecops=can_checked_malloc(sizeof(struct chipspecops_t));
+		if (chip->chipspecops==NULL)
 			return -ENOMEM;
-		else
-			if ( add_mem_to_list(candev->chip[i]->chipspecops) )
-				return -ENOMEM;
-
-		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]->flags=0x0;
+		
+                chips_p[irq_count]=chip;
+		chip->chip_idx=i;
+		chip->hostdevice=candev;
+		chip->chip_irq=irq[irq_count];
+		chip->baudrate=baudrate[irq_count]*1000;
+		if(!chip->baudrate)
+			chip->baudrate=baudrate[0]*1000;
+		chip->flags=0x0;
 
 		candev->hwspecops->init_chip_data(candev,i);
 
 		if (init_chipspecops(candev,i))
 			return -ENODEV;
-
-		init_obj_struct(candev, candev->chip[i], minor[irq_count]);
+		
+		init_obj_struct(candev, chip, minor[irq_count]);
 
 		irq_count++;
 	} 
@@ -294,28 +283,26 @@ 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;
 		obj->qends=qends;
 		obj->tx_qedge=NULL;
 		obj->tx_slot=NULL;
-		obj->flags = 0x0;
+		obj->obj_flags = 0x0;
 
 		canqueue_ends_init_chip(qends, hostchip, obj);
 		
@@ -335,93 +322,22 @@ int init_obj_struct(struct candevice_t *candev, struct chip_t *hostchip, int min
 
 int init_hwspecops(struct candevice_t *candev)
 {
-	#ifdef ENABLE_CARD_template
-	if (!strcmp(candev->hwname,"template")) {
-		template_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_pip
-	if (!strcmp(candev->hwname,"pip5")) {
-		pip5_register(candev->hwspecops);
-	}
-	else if (!strcmp(candev->hwname,"pip6")) {
-		pip6_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_smartcan
-	if (!strcmp(candev->hwname,"smartcan")) {
-		smartcan_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_nsi
-	if (!strcmp(candev->hwname,"nsican")) {
-		nsi_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_cc_can104
-	if (!strcmp(candev->hwname,"cc104")) {
-		cc104_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_aim104
-	if (!strcmp(candev->hwname,"aim104")) {
-		aim104_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_pc_i03
-	if (!strcmp(candev->hwname,"pc-i03")) {
-		pci03_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_pcm3680
-	if (!strcmp(candev->hwname,"pcm3680")) {
-		pcm3680_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_pccan
-	if (!strcmp(candev->hwname,"pccan-f") |
-		 !strcmp(candev->hwname,"pccan-s") ) {
-		pccanf_register(candev->hwspecops);
-	}
-	if (!strcmp(candev->hwname,"pccan-d")) {
-		pccand_register(candev->hwspecops);
-	}
-	if (!strcmp(candev->hwname,"pccan-q")) {
-		pccanq_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_m437
-	if (!strcmp(candev->hwname,"m437")) {
-		m437_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_pcccan
-	if (!strcmp(candev->hwname,"pcccan")) {
-		pcccan_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_ssv
-	if (!strcmp(candev->hwname,"ssv")) {
-		ssv_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_bfadcan
-	if (!strcmp(candev->hwname,"bfadcan")) {
-		bfadcan_register(candev->hwspecops);
-	}
-	#endif
-	#ifdef ENABLE_CARD_pikronisa
-	if (!strcmp(candev->hwname,"pikronisa")) {
-		pikronisa_register(candev->hwspecops);
+	const struct boardtype_t *brp;
+	
+	brp = boardtype_find(candev->hwname);
+	
+	if(!brp) {
+		CANMSG("Sorry, hardware \"%s\" is currently not supported.\n",candev->hwname);
+		return -EINVAL;
 	}
-	#endif
+	
+	brp->board_register(candev->hwspecops);
+
 	return 0;
 }
 
 int init_chipspecops(struct candevice_t *candev, int chipnr)
 {
-	candev->chip[chipnr]->max_objects=0;
-	
 	if (!strcmp(candev->chip[chipnr]->chip_type,"i82527")) {
 		candev->chip[chipnr]->max_objects=15;
 		i82527_register(candev->chip[chipnr]->chipspecops);
@@ -437,3 +353,32 @@ int init_chipspecops(struct candevice_t *candev, int chipnr)
 
 	return 0;
 }
+
+#ifndef CAN_WITH_RTL
+
+int can_chip_setup_irq(struct chip_t *chip)
+{
+	if(chip==NULL)
+		return -1;
+	if(!chip->chipspecops->irq_handler)
+		return 0;
+			
+	if (request_irq(chip->chip_irq,chip->chipspecops->irq_handler,SA_SHIRQ,DEVICE_NAME,chip))
+		return -1;
+	else {
+		DEBUGMSG("Registered interrupt %d\n",chip->chip_irq);
+		chip->flags |= CHIP_IRQ_SETUP;
+	}
+	return 1;
+}
+
+
+void can_chip_free_irq(struct chip_t *chip)
+{
+	if((chip->flags & CHIP_IRQ_SETUP) && (chip->chip_irq>=0)) {
+		free_irq(chip->chip_irq, chip);
+		chip->flags &= ~CHIP_IRQ_SETUP;
+	}
+}
+
+#endif /*CAN_WITH_RTL*/