From: Pavel Pisa <pisa@cmp.felk.cvut.cz>
Date: Mon, 29 Mar 2010 08:54:24 +0000 (+0200)
Subject: Merge branch 'master' into can-usb1
X-Git-Url: http://rtime.felk.cvut.cz/gitweb/lincan.git/commitdiff_plain/025f236cb5c28fe9992c2bf4b92c09a3d0cdb863?hp=-c

Merge branch 'master' into can-usb1
---

025f236cb5c28fe9992c2bf4b92c09a3d0cdb863
diff --combined lincan/include/can_sysdep.h
index 60f8f12,f6d985d..a18939f
--- a/lincan/include/can_sysdep.h
+++ b/lincan/include/can_sysdep.h
@@@ -213,6 -213,9 +213,9 @@@
  
  #ifdef __HAVE_ARCH_CMPXCHG
    #define CAN_HAVE_ARCH_CMPXCHG
+   #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+     #define CAN_HAVE_ATOMIC_CMPXCHG
+   #endif
  #endif
  
  #ifndef CAN_WITH_RTL
@@@ -288,20 -291,4 +291,20 @@@ extern can_spinlock_t can_irq_manipulat
  
  #endif /*CAN_WITH_RTL*/
  
 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,4))
 +	#include <linux/kthread.h>
 +	#define	can_kthread_create	kthread_create
 +	#define can_kthread_run	kthread_run
 +	#define can_kthread_bind	kthread_bind
 +	#define can_kthread_stop	kthread_stop
 +	#define can_kthread_should_stop	kthread_should_stop
 +#else
 +	#define	can_kthread_create
 +	#define can_kthread_run
 +	#define can_kthread_bind
 +	#define can_kthread_stop
 +	#define can_kthread_should_stop
 +#endif
 +
 +
  #endif /*_CAN_SYSDEP_H*/
diff --combined lincan/src/main.c
index 3aa24fa,5cc522e..197f37f
--- a/lincan/src/main.c
+++ b/lincan/src/main.c
@@@ -36,8 -36,6 +36,6 @@@
  #define EXPORT_SYMTAB
  #endif
  
- #include <linux/autoconf.h>
- 
  #include <linux/module.h>
  
  #include <linux/kernel.h>
@@@ -45,10 -43,10 +43,10 @@@
  #include <linux/sched.h>
  #include <linux/poll.h>
  #include <linux/version.h>
- #include <linux/autoconf.h>
  #include <linux/interrupt.h>
  
  #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0))
+  #include <linux/autoconf.h>
   #include <linux/wrapper.h>
  #else
   #include <linux/device.h>
@@@ -99,10 -97,6 +97,10 @@@
  #include "../include/can_iortl.h"
  #endif /*CAN_WITH_RTL*/
  
 +#if defined(CONFIG_OC_LINCAN_CARD_usbcan)
 +	#include "../include/usbcan.h"
 +#endif
 +
  can_spinlock_t canuser_manipulation_lock;
  
  int major=CAN_MAJOR;
@@@ -393,15 -387,6 +391,15 @@@ int init_module(void
               	}
          }
  #endif
 +
 +#if defined(CONFIG_OC_LINCAN_CARD_usbcan)
 +	res = usbcan_init();
 +	if (res){
 +		CANMSG("usb_register for usbcan failed. Error number %d.\n", res);
 +		return -ENODEV;
 +	}
 +#endif
 +
  	return 0;
  
  #ifdef CONFIG_PROC_FS
@@@ -440,227 -425,12 +438,227 @@@
  		return -ENODEV;
  }
  
 +
 +
 +
 +
 +struct candevice_t* register_usbdev(const char *hwname,void *devdata,void (*chipdataregfnc)(struct canchip_t *ch,void *data)){
 +	int i=0, j, board=0;
 +	struct candevice_t *candev;
 +	struct canchip_t *chip;
 +	struct boardtype_t *brp;
 +
 +	while ( (hw[board] != NULL) && (board < MAX_HW_CARDS) )
 +		board++;
 +	if (board>=MAX_HW_CARDS){
 +		CANMSG("Maximum number of devices has been reached, no space for new device");
 +		return NULL;
 +	}
 +	brp = boardtype_find(hwname);
 +	if(!brp) {
 +		CANMSG("Sorry, hardware \"%s\" is currently not supported.\n",hw[board]);
 +		return NULL;
 +	}
 +	if (board==MAX_HW_CARDS){
 +			CANMSG("Device \"%s\" could not be registered due to internal limits.\n",hw[board]);
 +			return NULL;
 +	}
 +	hw[board]=brp->boardtype;
 +
 +	if (init_new_hw_struct(board))
 +		return NULL;
 +
 +	#ifdef CAN_DEBUG
 +		list_hw();
 +	#endif
 +
 +	candev=hardware_p->candevice[board];
 +
 +	/* Adding link to usb device structure into can device */
 + 	candev->sysdevptr.anydev=devdata;
 +
 +	if (candev->hwspecops->request_io(candev))
 +		goto request_io_error;
 +	candev->flags|=CANDEV_IO_RESERVED;
 +
 +	if (candev->hwspecops->reset(candev))
 +		goto reset_error;
 +
 +	for(j=0; j<candev->nr_all_chips; j++) {
 +		if((chip=candev->chip[j])==NULL)
 +			continue;
 +
 +		chipdataregfnc(chip,devdata);
 +
 +		if(chip->chipspecops->attach_to_chip(chip)<0) {
 +			CANMSG("Initial attach to the chip HW failed\n");
 +			goto interrupt_error;
 +		}
 +
 +		chip->flags |= CHIP_ATTACHED;
 +
 +		if(can_chip_setup_irq(chip)<0) {
 +			CANMSG("Error to setup chip IRQ\n");
 +			goto interrupt_error;
 +		}
 +	}
 +
 +	if (candev->flags & CANDEV_PROGRAMMABLE_IRQ)
 +		if (candev->hwspecops->program_irq(candev)){
 +			CANMSG("Error to program board interrupt\n");
 +			goto interrupt_error;
 +		}
 +
 +#ifdef CONFIG_PROC_FS
 +	if (can_init_procentry(board))
 +		goto proc_error;
 +#endif
 +
 +#if defined(CONFIG_DEVFS_FS) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
 +	{
 +		#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0))
 +		char dev_name[32];
 +		#else
 +		struct class_device *this_dev;
 +		#endif
 +		int dev_minor;
 +		for(i=0;i<MAX_TOT_MSGOBJS;i++) {
 +			if(!objects_p[i]) continue;
 +			if(objects_p[i]->hostchip->hostdevice != candev) continue;
 +
 +			dev_minor=objects_p[i]->minor;
 +			#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0))
 +			sprintf (dev_name, "can%d", dev_minor);
 +			devfs_handles[i]=devfs_register(NULL, dev_name,
 +			DEVFS_FL_DEFAULT, major, dev_minor,
 +			S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
 +			&can_fops, (void*)objects_p[i]);
 +			#else
 +			#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,14))
 +			this_dev=class_device_create(can_class, MKDEV(major, dev_minor), NULL,  "can%d", dev_minor);
 +			#elif  LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,25) /* >= 2.6.15 */
 +			this_dev=class_device_create(can_class, NULL, MKDEV(major, dev_minor), NULL,  "can%d", dev_minor);
 +		        #elif  LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27)
 +			this_dev=device_create_drvdata(can_class, NULL, MKDEV(major, dev_minor), objects_p[i],  "can%d", dev_minor);
 +		        #else /* >= 2.6.28 */
 +			this_dev=device_create(can_class, NULL, MKDEV(major, dev_minor), objects_p[i],  "can%d", dev_minor);
 +		        #endif /* >= 2.6.28 */
 +			if(IS_ERR(this_dev)){
 +				CANMSG("problem to create device \"can%d\" in the class \"can\"\n", dev_minor);
 +		      #if  LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,25)
 +			}else{
 +				/*this_dev->class_data=objects_p[i];*/
 +				class_set_devdata(this_dev,objects_p[i]);
 +		      #endif /* <= 2.6.25 */
 +			}
 +			#ifdef CONFIG_DEVFS_FS
 +			devfs_mk_cdev(MKDEV(major, dev_minor), S_IFCHR | S_IRUGO | S_IWUGO, "can%d", dev_minor);
 +			#endif
 +			#endif
 +		}
 +	}
 +#endif
 +	return candev;
 +
 +#ifdef CONFIG_PROC_FS
 +	proc_error: ;
 +		CANMSG("Error registering /proc entry.\n");
 +		goto memory_error;
 +#endif
 +
 +	interrupt_error: ;
 +		goto memory_error;
 +
 +	reset_error: ;
 +		CANMSG("Error resetting device.\n");
 +		goto memory_error;
 +
 +	request_io_error: ;
 +		CANMSG("Error to request IO resources for device.\n");
 +		goto memory_error;
 +
 +	memory_error: ;
 +
 +		#ifdef CAN_WITH_RTL
 +	rtldev_error:
 +		#endif /*CAN_WITH_RTL*/
 +
 +//	register_error:
 +		if ( can_del_mem_list() )
 +			CANMSG("Error deallocating memory\n");
 +
 +		return NULL;
 +}
 +
 +
 +
 +
 +
 +
 +
 +void cleanup_usbdev(struct candevice_t *dev)
 +{
 +	int i=0;
 +	int dev_minor;
 +
 +	if (!dev)
 +		return;
 +
 +#ifdef CONFIG_PROC_FS
 +	if (can_delete_procentry(dev))
 +		CANMSG("Error unregistering /proc/can entry.\n");
 +#endif
 +
 +#if defined(CONFIG_DEVFS_FS) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
 +	for(i=0;i<MAX_TOT_MSGOBJS;i++) {
 +		if(!objects_p[i]) continue;
 +		if(objects_p[i]->hostchip->hostdevice != dev) continue;
 +		#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0))
 +		if(devfs_handles[i])
 +			devfs_unregister(devfs_handles[i]);
 +		#else
 +		dev_minor=objects_p[i]->minor;
 +		if(dev_minor>=0){
 +			#ifdef CONFIG_DEVFS_FS
 +			devfs_remove("can%d", dev_minor);
 +			#endif
 +			#if  LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,25)
 +			class_device_destroy(can_class, MKDEV(major, dev_minor));
 +			#else /* >= 2.6.26 */
 +			device_destroy(can_class, MKDEV(major, dev_minor));
 +			#endif /* >= 2.6.26 */
 +		}
 +		#endif
 +	}
 +#endif
 +
 +	for(i=0;i<MAX_TOT_CHIPS;i++){
 +		if(!chips_p[i]) continue;
 +		if(chips_p[i]->hostdevice != dev) continue;
 +		chips_p[i]=NULL;
 +	}
 +
 +	hardware_p->candevice[dev->candev_idx]=NULL;
 +	hardware_p->nr_boards--;
 +	hw[dev->candev_idx]=NULL;
 +
 +	candevice_done(dev);
 +	can_checked_free(dev);
 +}
 +
 +
 +
 +
  void cleanup_module(void)
  {
  #if defined(CONFIG_DEVFS_FS) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
  	int i=0;
  #endif
  
 +#if defined(CONFIG_OC_LINCAN_CARD_usbcan)
 +	usbcan_exit();
 +#endif
 +
  #ifdef CONFIG_PROC_FS
  	if (can_delete_procdir())
  		CANMSG("Error unregistering /proc/can entry.\n");