Merge branch 'master' into can-usb1
[lincan.git] / lincan / src / main.c
index c0c6d00..b8edf46 100644 (file)
 #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;
@@ -362,6 +366,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
@@ -400,12 +413,225 @@ int init_module(void)
                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);
+                       #else /* >= 2.6.26 */
+                       this_dev=device_create_drvdata(can_class, NULL, MKDEV(major, dev_minor), objects_p[i],  "can%d", dev_minor);
+                       #endif /* >= 2.6.26 */
+                       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");