packages/devs/can/loop/v2_0/tests/can_rdwr.c

   1 //==========================================================================
   2 //
   3 //        can_rdwr.c
   4 //
   5 //        Test CAN device drivers
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 //
  13 // eCos is free software; you can redistribute it and/or modify it under
  14 // the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 2 or (at your option) any later version.
  16 //
  17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 // for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License along
  23 // with eCos; if not, write to the Free Software Foundation, Inc.,
  24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 //
  26 // As a special exception, if other files instantiate templates or use macros
  27 // or inline functions from this file, or you compile this file and link it
  28 // with other works to produce a work based on this file, this file does not
  29 // by itself cause the resulting work to be covered by the GNU General Public
  30 // License. However the source code for this file must still be made available
  31 // in accordance with section (3) of the GNU General Public License.
  32 //
  33 // This exception does not invalidate any other reasons why a work based on
  34 // this file might be covered by the GNU General Public License.
  35 //
  36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 // at http://sources.redhat.com/ecos/ecos-license/
  38 // -------------------------------------------
  39 //####ECOSGPLCOPYRIGHTEND####
  40 //==========================================================================
  41 //#####DESCRIPTIONBEGIN####
  42 //
  43 // Author(s):     Uwe Kindler
  44 // Contributors:  Uwe Kindler
  45 // Date:          2005-08-07
  46 // Description:   Simple read/write test of CAN driver
  47 //####DESCRIPTIONEND####
  48
  49
  50 //===========================================================================
  51 //                                INCLUDES
  52 //===========================================================================
  53 #include <pkgconf/system.h>
  54
  55 #include <cyg/infra/testcase.h>         // test macros
  56 #include <cyg/infra/cyg_ass.h>          // assertion macros
  57 #include <cyg/infra/diag.h>
  58
  59 // Package requirements
  60 #if defined(CYGPKG_IO_CAN) && defined(CYGPKG_KERNEL)
  61
  62 #include <pkgconf/kernel.h>
  63 #include <cyg/io/io.h>
  64 #include <cyg/io/canio.h>
  65
  66 // Package option requirements
  67 #if defined(CYGFUN_KERNEL_API_C)
  68
  69 #include <cyg/hal/hal_arch.h>           // CYGNUM_HAL_STACK_SIZE_TYPICAL
  70 #include <cyg/kernel/kapi.h>
  71
  72
  73 //===========================================================================
  74 //                               DATA TYPES
  75 //===========================================================================
  76 typedef struct st_thread_data
  77 {
  78     cyg_thread   obj;
  79     long         stack[CYGNUM_HAL_STACK_SIZE_TYPICAL];
  80     cyg_handle_t hdl;
  81 } thread_data_t;
  82
  83
  84 //===========================================================================
  85 //                              LOCAL DATA
  86 //===========================================================================
  87 cyg_thread_entry_t can0_thread;
  88 thread_data_t      can0_thread_data;
  89
  90 cyg_thread_entry_t can1_thread;
  91 thread_data_t      can1_thread_data;
  92
  93
  94 //===========================================================================
  95 //                          LOCAL FUNCTIONS
  96 //===========================================================================
  97 #include "can_test_aux.inl" // include CAN test auxiliary functions
  98
  99
 100 //===========================================================================
 101 //                             WRITER THREAD
 102 //===========================================================================
 103 void can0_thread(cyg_addrword_t data)
 104 {
 105     cyg_io_handle_t    hCAN0;
 106     cyg_uint8          i;
 107     cyg_uint32         len;
 108     cyg_can_buf_info_t tx_buf_info;
 109     cyg_can_message    tx_msg =
 110     {
 111         0x000,                                               // CAN identifier
 112         {0x00, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7},    // 8 data bytes
 113         CYGNUM_CAN_ID_STD,                                   // standard frame
 114         CYGNUM_CAN_FRAME_DATA,                               // data frame
 115         8,                                                   // data length code
 116     };
 117
 118     if (ENOERR != cyg_io_lookup("/dev/can0", &hCAN0))
 119     {
 120         CYG_TEST_FAIL_FINISH("Error opening /dev/can0");
 121     }
 122
 123     len = sizeof(tx_buf_info);
 124     if (ENOERR != cyg_io_get_config(hCAN0, CYG_IO_GET_CONFIG_CAN_BUFFER_INFO ,&tx_buf_info, &len))
 125     {
 126         CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
 127     }
 128
 129     if (tx_buf_info.tx_bufsize < 10)
 130     {
 131         CYG_TEST_FAIL_FINISH("TX quesize of /dev/can0 too small for 10 CAN messages");
 132     }
 133
 134     while (1)
 135     {
 136         //
 137         // now we simply send 10 CAN messages and then suspend the thread
 138         //
 139         CYG_TEST_INFO("Thread0: Writing 10 CAN messages");
 140         for (i = 0; i < 10; ++i)
 141         {
 142             //
 143             // we store the message number as CAN id and in first data byte so
 144             // a receiver can check this later
 145             //
 146             tx_msg.id = 0x000 + i;
 147             tx_msg.data[0] = i;
 148             len = sizeof(tx_msg);
 149
 150             if (ENOERR != cyg_io_write(hCAN0, &tx_msg, &len))
 151             {
 152                 CYG_TEST_FAIL_FINISH("Error writing to /dev/can0");
 153             }
 154             else
 155             {
 156                 print_can_msg(&tx_msg, "");
 157             }
 158         }
 159
 160         //
 161         // Now we we give the reader thread a chance to run and to read
 162         // the messages
 163         //
 164         cyg_thread_delay(100);
 165         CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
 166     }
 167 }
 168
 169
 170 //===========================================================================
 171 //                            READER THREAD
 172 //===========================================================================
 173 void can1_thread(cyg_addrword_t data)
 174 {
 175     cyg_io_handle_t    hCAN1;
 176     cyg_uint8          i;
 177     cyg_uint32         len;
 178     cyg_can_buf_info_t rx_buf_info;
 179     cyg_can_event      rx_event;
 180
 181     if (ENOERR != cyg_io_lookup("/dev/can1", &hCAN1))
 182     {
 183         CYG_TEST_FAIL_FINISH("Error opening /dev/can1");
 184     }
 185
 186     len = sizeof(rx_buf_info);
 187     if (ENOERR != cyg_io_get_config(hCAN1, CYG_IO_GET_CONFIG_CAN_BUFFER_INFO ,&rx_buf_info, &len))
 188     {
 189         CYG_TEST_FAIL_FINISH("Error reading config of /dev/can1");
 190     }
 191
 192     if (rx_buf_info.rx_bufsize < 10)
 193     {
 194         CYG_TEST_FAIL_FINISH("RX quesize of /dev/can1 too small for 10 CAN events");
 195     }
 196
 197     while (1)
 198     {
 199         //
 200         // now we try to read the 10 CAN messages that was sent by writer
 201         // thread previously
 202         //
 203         CYG_TEST_INFO("Thread1: Reading 10 CAN messages");
 204         for (i = 0; i < 10; ++i)
 205         {
 206             len = sizeof(rx_event);
 207
 208             if (ENOERR != cyg_io_read(hCAN1, &rx_event, &len))
 209             {
 210                 CYG_TEST_FAIL_FINISH("Error reading from /dev/can1");
 211             }
 212
 213             //
 214             // we expect only RX events in this test case - so all other events
 215             // cause a test fail
 216             //
 217             if (!(rx_event.flags & CYGNUM_CAN_EVENT_RX))
 218             {
 219                 CYG_TEST_FAIL_FINISH("Received wrong CAN event type");
 220             }
 221
 222             //
 223             // The writer thread stored the message number in CAN id and first
 224             // data byte so we can check now if we received valid data
 225             //
 226             if ((rx_event.msg.id != i) || (rx_event.msg.data[0] != i))
 227             {
 228                 CYG_TEST_FAIL_FINISH("Received CAN message contains unexpected data");
 229             }
 230             else
 231             {
 232                 print_can_msg(&rx_event.msg, "");
 233             }
 234         } //for (i = 0; i < 10; ++i)
 235
 236         CYG_TEST_PASS_FINISH("can_rdwr test OK");
 237     } // while (1)
 238 }
 239
 240
 241
 242 void
 243 cyg_start(void)
 244 {
 245     CYG_TEST_INIT();
 246
 247     //
 248     // create the two threads which access the CAN device driver
 249     //
 250     cyg_thread_create(4, can0_thread,
 251                         (cyg_addrword_t) 0,
 252                                 "can0_thread",
 253                                 (void *) can0_thread_data.stack,
 254                                 1024 * sizeof(long),
 255                                 &can0_thread_data.hdl,
 256                                 &can0_thread_data.obj);
 257
 258     cyg_thread_create(5, can1_thread,
 259                         (cyg_addrword_t) can0_thread_data.hdl,
 260                                 "can1_thread",
 261                                 (void *) can1_thread_data.stack,
 262                                 1024 * sizeof(long),
 263                                 &can1_thread_data.hdl,
 264                                 &can1_thread_data.obj);
 265
 266     cyg_thread_resume(can0_thread_data.hdl);
 267     cyg_thread_resume(can1_thread_data.hdl);
 268
 269     cyg_scheduler_start();
 270 }
 271
 272 #else // CYGFUN_KERNEL_API_C
 273 #define N_A_MSG "Needs kernel C API"
 274 #endif
 275
 276 #else // CYGPKG_IO_CAN && CYGPKG_KERNEL
 277 #define N_A_MSG "Needs IO/CAN and Kernel"
 278 #endif
 279
 280 #ifdef N_A_MSG
 281 void
 282 cyg_start( void )
 283 {
 284     CYG_TEST_INIT();
 285     CYG_TEST_NA( N_A_MSG);
 286 }
 287 #endif // N_A_MSG
 288
 289 // EOF serial4.c