embedded: reintroduce missing emulated bus initialization for UL_USB1 board.

[lincan.git] / embedded / app / usbcan / main.c

diff --git a/embedded/app/usbcan/main.c b/embedded/app/usbcan/main.c
index 0aff2218bee382771d2a40ffbe8532ee352dd1ad..14fbe288e98c5eb5bf7b1b3c841e744a49dcb951 100644 (file)
--- a/embedded/app/usbcan/main.c
+++ b/embedded/app/usbcan/main.c
@@ -1,3 +1,35 @@
+/**************************************************************************/
+/* File: main.c - setup and main loop of USB<->CAN converter              */
+/*                                                                        */
+/* LinCAN - (Not only) Linux CAN bus driver                               */
+/* Copyright (C) 2002-2011 DCE FEE CTU Prague <http://dce.felk.cvut.cz>   */
+/* Copyright (C) 2008 Jan Kriz email:johen@post.cz                        */
+/*                                                                        */
+/* LinCAN is free software; you can redistribute it and/or modify it      */
+/* under terms of the GNU General Public License as published by the      */
+/* Free Software Foundation; either version 2, or (at your option) any    */
+/* later version.  LinCAN is distributed in the hope that it will be      */
+/* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
+/* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
+/* General Public License for more details. You should have received a    */
+/* copy of the GNU General Public License along with LinCAN; see file     */
+/* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
+/* Cambridge, MA 02139, USA.                                              */
+/*                                                                        */
+/* To allow use of LinCAN in the compact embedded systems firmware        */
+/* and RT-executives (RTEMS for example), main authors agree with next    */
+/* special exception:                                                     */
+/*                                                                        */
+/* Including LinCAN header files in a file, instantiating LinCAN generics */
+/* or templates, or linking other files with LinCAN objects to produce    */
+/* an application image/executable, does not by itself cause the          */
+/* resulting application image/executable to be covered by                */
+/* the GNU General Public License.                                        */
+/* This exception does not however invalidate any other reasons           */
+/* why the executable file might be covered by the GNU Public License.    */
+/* Publication of enhanced or derived LinCAN files is required although.  */
+/**************************************************************************/
+

 #include <stdio.h>
 #include <string.h>
 #include <cpu_def.h>
 #include <stdio.h>
 #include <string.h>
 #include <cpu_def.h>


@@ -28,12 +60,16 @@
 #include "./can/modparms.h"
 #include "./can/devcommon.h"
 
 #include "./can/modparms.h"
 #include "./can/devcommon.h"
 

-#include "./can/ul_usb1.h"
-//#include "./can/setup.h"
+//#include "./can/ul_usb1.h"
+
+#include "./can/setup.h"

 
 #include "./usb/usb_defs.h"
 #include "./usb/usb_vend.h"
 
 
 #include "./usb/usb_defs.h"
 #include "./usb/usb_vend.h"
 

+extern int can_lmc1_register(struct hwspecops_t *hwspecops);
+extern int ul_usb1_register(struct hwspecops_t *hwspecops);
+

 #define MASK_EP1RX  0x01
 #define MASK_EP1TX  0x02
 
 #define MASK_EP1RX  0x01
 #define MASK_EP1TX  0x02
 


@@ -73,7 +109,6 @@ typedef void (*FNC)(); //function ptr
  * global variables
  ***********************************************************************/
 
  * global variables
  ***********************************************************************/
 

-

 usb_device_t usb_device;
 
 usb_ep_t eps[NUM_ENDPOINTS];
 usb_device_t usb_device;
 
 usb_ep_t eps[NUM_ENDPOINTS];


@@ -103,6 +138,7 @@ extern int register_obj_struct(struct msgobj_t *obj, int minorbase);
  ***********************************************************************/
 
 int sys_err(){
  ***********************************************************************/
 
 int sys_err(){

+  

   unsigned char i=0;
 
   while(1) {
   unsigned char i=0;
 
   while(1) {


@@ -130,6 +166,7 @@ void timer_10ms(void)
   else SET_OUT_PIN(LED_PORT,LED1_BIT);
   if (timer_rx_off!=0) timer_rx_off--;
   else SET_OUT_PIN(LED_PORT,LED2_BIT);
   else SET_OUT_PIN(LED_PORT,LED1_BIT);
   if (timer_rx_off!=0) timer_rx_off--;
   else SET_OUT_PIN(LED_PORT,LED2_BIT);

+

 /*  if (timer_configured!=0) timer_configured--;
   else {
     timer_configured=20;
 /*  if (timer_configured!=0) timer_configured--;
   else {
     timer_configured=20;


@@ -162,23 +199,24 @@ int main(void)
 //     volatile int i=0;
        bootloader_run=0;
        /***********************************/
 //     volatile int i=0;
        bootloader_run=0;
        /***********************************/

+

        lt_10msec_init();
        lt_100msec_init();
        lt_2sec_init();
 
        lt_10msec_init();
        lt_100msec_init();
        lt_2sec_init();
 

-       SET_OUT_PIN(LED_PORT,LED_ERR);
-       CLR_OUT_PIN(LED_PORT,LED_GP);
+       // DEBUG
+       //SET_OUT_PIN(LED_PORT,LED_ERR);
+       //CLR_OUT_PIN(LED_PORT,LED_GP);

 
        if (USB_MAX_PACKET<16){
                CANMSG("Maximum packet size less than 16B (is %dB)\n",USB_MAX_PACKET);
                sys_err();
        }
 
 
        if (USB_MAX_PACKET<16){
                CANMSG("Maximum packet size less than 16B (is %dB)\n",USB_MAX_PACKET);
                sys_err();
        }
 

-       /***********************************************************************
-        * CAN device initialization - device side (adapted from LinCAN setup.c)
-        ***********************************************************************/

 
 

-       can_init();
+       // ***********************************************************************
+       // * CAN device initialization - device side (adapted from LinCAN setup.c)
+       // ***********************************************************************

 
        DEBUGMSG("Initiating CAN device initialization\n");
        baudrate[0]=1000;
 
        DEBUGMSG("Initiating CAN device initialization\n");
        baudrate[0]=1000;


@@ -206,22 +244,33 @@ int main(void)
        }
        memset(candev->hwspecops, 0, sizeof(struct hwspecops_t));
 
        }
        memset(candev->hwspecops, 0, sizeof(struct hwspecops_t));
 

+       
+
+#ifdef CONFIG_OC_LINCAN_CARD_ul_usb1

        ul_usb1_register(candev->hwspecops);
        ul_usb1_register(candev->hwspecops);

+#endif
+#ifdef CONFIG_OC_LINCAN_CARD_can_lmc1
+       can_lmc1_register(candev->hwspecops);
+#endif

 
        bd=baudrate[0];
        if (candev->hwspecops->init_hw_data(candev)){
                CANMSG("HW data could not be initialized\n");
                sys_err();
        }
 
        bd=baudrate[0];
        if (candev->hwspecops->init_hw_data(candev)){
                CANMSG("HW data could not be initialized\n");
                sys_err();
        }

-       /* Alocate and initialize the chip structures */
+
+       // Alocate and initialize the chip structures

        for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
        for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {

-/*             if(chipnr<irqnum)
-                       irqsig=irq[*irq_param_idx_p+chipnr];*/
+//             if(chipnr<irqnum)
+//                     irqsig=irq[*irq_param_idx_p+chipnr];

                if (init_chip_struct(candev, chipnr, 0, bd*1000)){
                        CANMSG("Chip structure could not be initialized\n");
                        sys_err();
                }
        }
                if (init_chip_struct(candev, chipnr, 0, bd*1000)){
                        CANMSG("Chip structure could not be initialized\n");
                        sys_err();
                }
        }

+
+
+

        for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
                struct canchip_t *chip=candev->chip[chipnr];
                int objnr;
        for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
                struct canchip_t *chip=candev->chip[chipnr];
                int objnr;


@@ -233,11 +282,21 @@ int main(void)
                        if(m>=0) m++;
                }
        }
                        if(m>=0) m++;
                }
        }

-       if (candev->hwspecops->request_io(candev))
+
+
+       if (candev->hwspecops->request_io(candev)) {
+               CANMSG("Error to request IO\n");

                sys_err();
                sys_err();

+       }

        candev->flags|=CANDEV_IO_RESERVED;
        candev->flags|=CANDEV_IO_RESERVED;

-       if (candev->hwspecops->reset(candev))
+
+
+       if (candev->hwspecops->reset(candev)) {
+               CANMSG("Error to reset chip\n");

                sys_err();
                sys_err();

+       }
+
+

        for(chipnr=0; chipnr<candev->nr_all_chips; chipnr++) {
                if((chip=candev->chip[chipnr])==NULL)
                        continue;
        for(chipnr=0; chipnr<candev->nr_all_chips; chipnr++) {
                if((chip=candev->chip[chipnr])==NULL)
                        continue;


@@ -249,11 +308,12 @@ int main(void)
 
                chip->flags |= CHIP_ATTACHED;
 
 
                chip->flags |= CHIP_ATTACHED;
 

-// Interrupts from chip are served in main cycle
-/*             if(can_chip_setup_irq(chip)<0) {
-//                     CANMSG("Error to setup chip IRQ\n");
+               // used with lpc17xx:
+               if(can_chip_setup_irq(chip)<0) {
+                       CANMSG("Error to setup chip IRQ\n");

                        sys_err();
                        sys_err();

-               }*/
+               }
+

        }
 
        if (candev->flags & CANDEV_PROGRAMMABLE_IRQ)
        }
 
        if (candev->flags & CANDEV_PROGRAMMABLE_IRQ)


@@ -262,9 +322,10 @@ int main(void)
                        sys_err();
                }
 
                        sys_err();
                }
 

-       /***********************************************************************
-        * CAN device initialization - client side (adapted from LinCAN open.c)
-        ***********************************************************************/
+       //***********************************************************************
+       // * CAN device initialization - client side (adapted from LinCAN open.c)
+       // ***********************************************************************
+

 
        chip=candev->chip[0];
        obj=chip->msgobj[0];
 
        chip=candev->chip[0];
        obj=chip->msgobj[0];


@@ -282,7 +343,8 @@ int main(void)
                if (chip->chipspecops->pre_read_config(chip,obj)<0)
                        CANMSG("Error initializing chip for receiving\n");
 
                if (chip->chipspecops->pre_read_config(chip,obj)<0)
                        CANMSG("Error initializing chip for receiving\n");
 

-       } /* End of chip configuration */
+       } // End of chip configuration
+

 
        canuser = (struct canuser_t *)malloc(sizeof(struct canuser_t));
        if(canuser == NULL) sys_err();
 
        canuser = (struct canuser_t *)malloc(sizeof(struct canuser_t));
        if(canuser == NULL) sys_err();


@@ -297,7 +359,7 @@ int main(void)
        canqueue_ends_init_kern(qends);
        canuser->qends = qends;
 
        canqueue_ends_init_kern(qends);
        canuser->qends = qends;
 

-       /*required to synchronize with RT-Linux context*/
+       //required to synchronize with RT-Linux context

        can_spin_lock_irqsave(&canuser_manipulation_lock, iflags);
        list_add(&canuser->peers, &obj->obj_users);
        can_spin_unlock_irqrestore(&canuser_manipulation_lock, iflags);
        can_spin_lock_irqsave(&canuser_manipulation_lock, iflags);
        list_add(&canuser->peers, &obj->obj_users);
        can_spin_unlock_irqrestore(&canuser_manipulation_lock, iflags);


@@ -307,11 +369,12 @@ int main(void)
 
        if(canqueue_connect_edge(canuser->rx_edge0=canque_new_edge_kern(MAX_BUF_LENGTH),
                obj->qends, canuser->qends)<0) sys_err();
 
        if(canqueue_connect_edge(canuser->rx_edge0=canque_new_edge_kern(MAX_BUF_LENGTH),
                obj->qends, canuser->qends)<0) sys_err();

-       /*FIXME: more generic model should be used there*/
+       //FIXME: more generic model should be used there

        canque_edge_decref(canuser->rx_edge0);
        canque_edge_decref(edge);
 
 
        canque_edge_decref(canuser->rx_edge0);
        canque_edge_decref(edge);
 
 

+

        /***********************************************************************
         * USB Init
         ***********************************************************************/
        /***********************************************************************
         * USB Init
         ***********************************************************************/


@@ -344,16 +407,25 @@ int main(void)
         ***********************************************************************/
 
        timer_rx_off=timer_tx_off=timer_str=timer_configured=0;
         ***********************************************************************/
 
        timer_rx_off=timer_tx_off=timer_str=timer_configured=0;

+
+
+       printf("Main loop\n");
+

        while (1) {
 
                usb_check_events(&usb_device);
                usb_control_response(&usb_device);
 
        while (1) {
 
                usb_check_events(&usb_device);
                usb_control_response(&usb_device);
 

-               if (!(IO0PIN&P0_SJA1000_INT_PIN)) //INT PIN is inverted
+#ifdef CONFIG_OC_LINCAN_CARD_ul_usb1
+               /* polled IRQ mode for ul_usb1 board*/
+               if (!(IO0PIN&P0_SJA1000_INT_PIN)) /* INT PIN is inverted */

                        chip->chipspecops->irq_handler(0,chip);
                        chip->chipspecops->irq_handler(0,chip);

+#endif

 
                if (usb_device.ep_events & MASK_EP1RX) {  //EP1RX - data waiting to receive
 
                if (usb_device.ep_events & MASK_EP1RX) {  //EP1RX - data waiting to receive

+                       

                        if (canque_get_inslot(qends, &qedge, &slot, 0)>=0){ //Free slot obtained
                        if (canque_get_inslot(qends, &qedge, &slot, 0)>=0){ //Free slot obtained

+

                                size=usb_udev_read_endpoint(&eps[0],ep1_rx_buff,16);
                                if (size==16){
                                        uint16_t msgflags;
                                size=usb_udev_read_endpoint(&eps[0],ep1_rx_buff,16);
                                if (size==16){
                                        uint16_t msgflags;


@@ -380,16 +452,22 @@ int main(void)
                                        /* Automatic selection of extended format if ID>2047 */
                                        if (canmsg.id & ~0x7ffl & MSG_ID_MASK ) canmsg.flags |= MSG_EXT;
                                        /* has been dependent on "extended" option */
                                        /* Automatic selection of extended format if ID>2047 */
                                        if (canmsg.id & ~0x7ffl & MSG_ID_MASK ) canmsg.flags |= MSG_EXT;
                                        /* has been dependent on "extended" option */

+                       

                                        slot->msg=canmsg;
                                        canque_put_inslot(qends, qedge, slot);
                                        slot->msg=canmsg;
                                        canque_put_inslot(qends, qedge, slot);

+

                                }
                                else
                                        canque_abort_inslot(qends,qedge,slot);
                                }
                                else
                                        canque_abort_inslot(qends,qedge,slot);

+                                       
+

                                timer_rx_off=50;        //rosviceni diody pri prijmu
                                CLR_OUT_PIN(LED_PORT,LED2_BIT);
                                usb_device.ep_events &= ~MASK_EP1RX;
                                timer_rx_off=50;        //rosviceni diody pri prijmu
                                CLR_OUT_PIN(LED_PORT,LED2_BIT);
                                usb_device.ep_events &= ~MASK_EP1RX;

+                       
+                                       

                        }
                        }

-
+                       

 
 /*                     if (size==2){
                                uint8_t val;
 
 /*                     if (size==2){
                                uint8_t val;


@@ -409,6 +487,7 @@ int main(void)
                        }*/
                }
 
                        }*/
                }
 

+               

                if(usb_device.ep_events & MASK_EP1TX){ //EP1TX - data transmitted
                        if(canque_test_outslot(qends, &qedge, &slot)>=0){
                                DEBUGMSG("CAN message ready to send over usb\n");
                if(usb_device.ep_events & MASK_EP1TX){ //EP1TX - data transmitted
                        if(canque_test_outslot(qends, &qedge, &slot)>=0){
                                DEBUGMSG("CAN message ready to send over usb\n");


@@ -439,8 +518,12 @@ int main(void)
                                timer_tx_off=50;                //rozsviceni diod pri vysilani
                                CLR_OUT_PIN(LED_PORT,LED1_BIT);
                                usb_device.ep_events &= ~MASK_EP1TX;
                                timer_tx_off=50;                //rozsviceni diod pri vysilani
                                CLR_OUT_PIN(LED_PORT,LED1_BIT);
                                usb_device.ep_events &= ~MASK_EP1TX;

+

                        }
                        }

+                       
+

                }
                }

+               

 
                //if (usb_can_send && )
 
 
                //if (usb_can_send && )