lincan/include/unican_cl2.h

   1 /******************************************************************************
   2
   3 Cl2.H - PCAN and VCAN cards hardware access library
   4 """"""""
   5                    (C) Copyright 1997   Unicontrols a.s.
   6
   7 PROJEKT            :    CANopen
   8 AUTOR              :    F.Spurny
   9 FIRMA              :    CVUT FEL, Dept. of Measurement
  10 PORTING            :    Adapted for LinCAN driver by Pavel Pisa, OCERA team member
  11
  12 DULEZITE UPOZORNENI:
  13
  14 ARCHIVACNI INFORMACE:
  15 Log: unican_cl2.h,v
  16
  17 27.1.1999 - corected value of CL2_ERROR_WARNING and CL2_ERROR_BUS_OFF constants
  18
  19 12.12.2000 - CL2_STATUS_RESET_CARD, CL2_ERROR_RESET_CARD added
  20              fields of sCAN_MESSAGE aligned
  21
  22 10.8.2001 - PCI PCAN ID registers content defined
  23         - cl2_find_card function prototype added
  24         - cl2_get_ID function prototype added
  25
  26 10.2.2004 - Start of PCAN support porting to RT-Linux and Linux environment
  27
  28 ===============================================================================
  29
  30 UCEL A FUNKCE:
  31
  32 ******************************************************************************/
  33
  34 #ifndef __INC_CL2_H
  35 #define __INC_CL2_H
  36
  37
  38 /****** includes ******/
  39
  40 #ifndef __INC_ANCTYPES_H
  41 #include "unican_types.h"
  42 #endif
  43
  44 /****** Definitions of constants  ******/
  45
  46 /* PCI card Configuration Space Constants */
  47 #define PCANDeviceID                    0x0101
  48 #define PCANVendorID                    0xFA3C
  49 #define PCANSubsystemID                 0x0001
  50 #define PCANSubsystemVendorID           0x7A52
  51
  52
  53 /* Description of card and card registers location. Registers location are
  54  * mapped relative to card base address (BA) */
  55
  56 #define CL2_RAM_SIZE                    0x1000  /* size of dual-port RAM */
  57 #define CL2_RX_BUFFER_DEFAULT           0x800   /* off(BA->rx buffer) */
  58 #define CL2_SYNC_BUFFER_DEFAULT         0x400   /* off(BA->sync buffer) */
  59 #define CL2_ASYNC_BUFFER_DEFAULT        0x600   /* off(BA->async buffer) */
  60 #define CL2_COMMAND_REGISTER            0x3FE   /* off(BA->command register )*/
  61 #define CL2_VERSION_REGISTER            0x3F6   /* off(BA->version register )*/
  62 #define CL2_ID_REGISTER                 0x3EE   /* off(BA->ID register) */
  63 #define CL2_GEN_INT_REGISTER            0x3E4   /* off(BA->generate interrupt reg.)*/
  64 #define CL2_CLEAR_INT_REGISTER          0x3E2   /* off(BA->clear interrupt reg)*/
  65 #define CL2_RESET_REGISTER              0x3E0   /* off(BA->reset register)*/
  66 #define CL2_ERROR_REGISTER              0x3F8   /* off(BA->error register)*/
  67 #define CL2_TIME_REGISTER                       0x3FC   /* currently not used */
  68 #define CL2_START_IT_REGISTER           0x3E6   /* off(BA->start inhibit time reg.) */
  69 #define CL2_STATUS_REGISTER             0x3FA   /* off(BA->status register)*/
  70 #define CL2_VME_INT_VECTOR              0x3F0
  71 #define CL2_DATA_BUFFER                 0x100   /* off(BA->data buffer)*/
  72
  73 /* Default sizes of buffers (in messages)
  74  * FYI: 1 message needs 16 bytes to be stored */
  75 #define CL2_RX_BUFFER_SIZE                              128     /* size of receive (rx) buffer */
  76 #define CL2_TX_SYNC_BUFFER_SIZE         32              /* size of synchronnous buffer */
  77 #define CL2_TX_ASYNC_BUFFER_SIZE                32              /* size of asynchronnous buffer*/
  78
  79 /* Command valid flag */
  80 #define CL2_COMMAND_VALID                        0x0080
  81
  82 /* Message flags */
  83 #define CL2_MESSAGE_VALID         0x0001
  84
  85 /* status bits */
  86 #define CL2_DATA_IN_RBUF          0x0001   /* message is in rx buffer*/
  87 #define CL2_X_DATA_IN_RBUF        0x0002   /* more than LIMIT messages are in
  88                                                                                                                   * rx buffer*/
  89 #define CL2_RBUF_OVERFLOW         0x0004   /* owerflow of rx buffer, some
  90                                             * messages are lost*/
  91 #define CL2_SYNC_QUEUE_EMPTY      0x0010   /* sync queue is empty */
  92 #define CL2_ASYNC_QUEUE_EMPTY     0x0020   /* async queue is empty */
  93 #define CL2_CARD_ERROR            0x0040   /* card reports an error */
  94 #define CL2_STATUS_VALID_FLAG     0x0080   /* bit indicating that status
  95                                             * register contains valid data*/
  96 #define CL2_CARD_READY            0x0100   /* card is ready */
  97 #define CL2_SYNC_PASSIVE          0x0200   /* passive SYNC mode */
  98 #define CL2_SYNC_ACTIVE           0x0400   /* active SYNC mode */
  99 #define CL2_RTR_LIST              0x0800   /* RTR list sending */
 100 #define CL2_STATUS_RESET_CARD     0x8000   /* card reset occurred */
 101
 102 /* error bits */
 103 #define CL2_ERROR_LL              0x0007   /*  */
 104 #define CL2_ERROR_WARNING         0x0040   /* bus warning detected */
 105 #define CL2_ERROR_BUS_OFF         0x0080   /* bus error detected */
 106 #define CL2_ERROR_RESET_CARD      0x0100   /* card reset occurred */\r
 107 #define CL2_ERROR_FIRMWARE        0x1000   /* firmware error detected */
 108 #define CL2_ERROR_DPRAM           0x2000   /* dual port RAM error detected */
 109 #define CL2_ERROR_RAM             0x4000   /* internal RAM error detected */
 110 #define CL2_ERROR_CAN             0x8000   /* CAN controller error detected */
 111
 112 /* interrupt generation */
 113 #define INT_MODE_RX               0x01     /* if data are in receive buffer*/
 114 #define INT_MODE_ERROR            0x02     /* if any error occurs */
 115 #define INT_MODE_SYNC_EMPTY       0x04     /* if tx sync. queue is empty*/
 116 #define INT_MODE_ASYNC_EMPTY      0x08     /* if tx async. queue is empty*/
 117 #define INT_MODE_ALL              0x0F     /* if any event occurs*/
 118
 119 /* CAN message types */
 120 #define CL2_REMOTE_FRAME          0x08     /* frame is a remote frame*/
 121 #define CL2_LINE_FLAG             0x80
 122 #define CL2_EXT_FRAME             0x04     /* frame is extended format*/
 123
 124 /* Receive message flags */
 125 #define CL2_FRAME_VALID           0x01     /* message in buffer is valid */
 126 #define CL2_RX_OVERFLOW           0x02     /* stored unread message was
 127                                             * overwritten by another one */
 128
 129 /* Bitrates */
 130 #define CL2_BITRATE_5K            0x7f7f   /* bit-rate 5 kb/s */
 131 #define CL2_BITRATE_10K           0x5c67   /* bit-rate 10 kb/s */
 132 #define CL2_BITRATE_20K           0x5c53   /* bit-rate 20 kb/s */
 133 #define CL2_BITRATE_50K           0x5c47   /* bit-rate 50 kb/s */
 134 #define CL2_BITRATE_100K          0x5c43   /* bit-rate 100 kb/s */
 135 #define CL2_BITRATE_125K          0x6743   /* bit-rate 125 kb/s */
 136 #define CL2_BITRATE_200K          0x5c41   /* bit-rate 200 kb/s */
 137 #define CL2_BITRATE_250K          0x6741   /* bit-rate 250 kb/s */
 138 #define CL2_BITRATE_500K          0x6740   /* bit-rate 500 kb/s */
 139 #define CL2_BITRATE_800K          0x3440   /* bit-rate 800 kb/s */
 140 #define CL2_BITRATE_1M            0x2340   /* bit-rate 1 Mb/s */
 141
 142
 143 /****** Definition of structures  ******/
 144
 145 typedef struct  /*** card definition structure ***/
 146         {
 147         U16  intNumber;         /* Card interrupt (IRQ) number */
 148         U8   *baseAddressPtr;   /* Pointer to card base address (BA) */
 149         U8   *rxBufPtr;         /* Pointer to receive buffer */
 150         U8   *rxBufBase;        /* Pointer to empty receive buffer */
 151         U8   *asyncTxBufPtr;    /* Pointer to async transmit buffer */
 152         U8   *asyncTxBufBase;   /* Pointer to empty async. transmit buffer */
 153         U8   *syncTxBufPtr;     /* Pointer to sync. transmit buffer */
 154         U8   *syncTxBufBase;    /* Pointer to empty sync. transmit buffer */
 155         U8   *commandRegister;  /* Pointer to command register */
 156         U8   *dataPtr;          /* Pointer to command data buffer */
 157         U16  rxBufSize;         /* size of receive buffer (x16 bytes) */
 158         U16  syncTxBufSize;     /* size of sync. transmit buffer (x16 bytes)*/
 159         U16  asyncTxBufSize;    /* size of async. transmit buffer (x 16 bytes)*/
 160         U16  status;            /* last card status */
 161         U16  error;             /* last not reported card error */
 162         U32 rtrSub[10];
 163         } sCAN_CARD;
 164
 165 //typedef struct  /*** CAN message formet ***/
 166 //      {
 167 //      U8   data[8];           /* Data message buffer (8 bytes) */
 168 //      U8   dataLength;        /* Data length (in bytes) */
 169 //      U32  COB_ID;            /* COB_ID */
 170 //      U16  timeStamp;         /* Message time stamp */
 171 //      U8   dataType;          /* Message data type */
 172 //      } sCAN_MESSAGE;
 173
 174 typedef struct
 175    {
 176    U32  COB_ID;             /* COB identifier */
 177    U8   dataType;          /* Message data type */
 178    U8   dataLength;        /* Data length (in bytes) */
 179    U8   data[8];           /* Data message buffer (8 bytes) */
 180    U16  timeStamp;         /* Message time stamp [us] */
 181    } sCAN_MESSAGE;
 182
 183
 184 typedef struct  /*** Remote Request RTR frame ***/
 185    {
 186    U32  cob_id;           /* RTR frame ID */
 187    U16  period;           /* RTR period */
 188    U16  subperiod;        /* RTR subperiod */
 189    } sRTR_FRAME;
 190
 191 typedef struct  /*** Remote Request (RTR) list ***/
 192         {
 193         sRTR_FRAME *data;       /* RTR data */
 194         U32 nb;                 /* Number of RTR definitions */
 195         } sRTR_LIST;
 196
 197 typedef enum  /*** CL2 functions return codes ***/
 198         {
 199         CL2_OK = 0,           /* OK */
 200         CL2_NO_REQUEST,       /* No request*/
 201         CL2_HW_FAILURE,       /* HW failure */
 202         CL2_HW_QUEUE_FULL,    /* Transmit queue full */
 203         CL2_BAD_PARAM,        /* Bad number of parameters */
 204    CL2_HW_QUEUE_EMPTY,   /* Receive queue empty */
 205         CL2_COMMAND_BUSY,     /* Command busy - previous command not completed */
 206         CL2_UNKNOWN_COMMAND,  /* Unknown command */
 207         CL2_NO_PCI_BIOS          /* missing PCI BIOS support */
 208    } eCL2_RESULT;
 209
 210 typedef enum  /*** CL2 commands ***/
 211    {
 212    cmCL2_INT_MODE = 0x01,            /**01 - Set Interrupt mode */
 213    cmCL2_IIT_MODE,                   /**02 - Inhibit Interrupt Time mode */
 214    cmCL2_SYNC_MODE,                  /**03 - SYNC mode */
 215         cmCL2_RTR_MODE,                   /**04 - RTR list mode */
 216         cmCL2_BUF_SIZE,                   /**05 - Set buffers sizes */
 217    cmCL2_SET_IIT,                    /**06 - Start Inhibit Interrupt Time */
 218    cmCL2_START_FIRMWARE,             /**07 - Start firmware */
 219    cmCL2_LOAD_FIRMWARE,              /* 08 - Load firmware */
 220         cmCL2_SET_REC_MODE,               /**09 - Set Receive mode */
 221
 222    cmCL2_CLR_RX_BUFFER = 0x10,       /**10 - Clear receive buffer */
 223    cmCL2_CLR_SYNC_BUFFER,            /**11 - Clear synchronous buffer */
 224    cmCL2_CLR_ASYNC_BUFFER,           /**12 - Clear asynchronous buffer */
 225         cmCL2_SEND_TIME_SYNC,             /**13 - Sends time synchronization */
 226         cmCL2_SET_TIME_COBID,             /**14 - Sets time frames COB-ID */
 227    cmCL2_SET_RECEIVE_LIMIT,          /* 15 - Sets receive limit */
 228
 229         cmCL2_DOWNLOAD_RTR_LIST = 0x20,   /**20 - Download RTR list */
 230    cmCL2_SUBSCRIBE_RTR,              /**21 - Subscribe RTR */
 231    cmCL2_DESUBSCRIBE_RTR,            /* 22 - Desubscribe RTR */
 232
 233    cmCL2_SET_COBID = 0x30,           /**30 - Set COB-ID */
 234    cmCL2_SET_SYNC_PERIOD,            /**31 - Set SYNC period */
 235    cmCL2_SET_SYNC_WINDOW,            /**32 - Set SYNC period window */
 236
 237         cmCL2_SET_BITRATE = 0x40,         /**40 - Set CAN bit rate */
 238         cmCL2_BUS_RESET                   /* 41 - CAN controller reset */
 239
 240         } eCLU2_COMMAND;
 241
 242
 243 /****** prototypes ******/
 244
 245
 246 /*******************************************************************************
 247 * cl2_find_card - find PCIPCAN card
 248 * """""""""""""
 249 *
 250 * Searches for PCIPCAN cards in the system. The mapping (memory and interrupt)
 251 * of the card is found. An index parameter specifies how many PCIPCAN cards have
 252 * to be skipped in search.
 253 *
 254 * RETURNS:
 255 *   CL2_OK - card found and mapped under 1 MB
 256 *   CL2_HW_FAILURE - card not found or not mapped under 1 MB
 257 */
 258 eCL2_RESULT cl2_find_card
 259          (
 260          U16 *baseAddress,               /* card's physical base address */
 261          U16 *intNumber,                 /* card's interrupt level */
 262          U16 index                  /* number of PCIPCAN cards to be skipped */
 263          );
 264
 265
 266 /*******************************************************************************
 267 * cl2_init_card - initialize card to default parameters
 268 * """""""""""""
 269 *
 270 * Command installs card. The data in sCAN_CARD structure pointed
 271 * by *card are initialized to their predefined default values.
 272 * Command must be called before any operation with sCAN_CARD
 273 * structure.
 274 *
 275 * RETURNS:
 276 *   CL2_OK - command completed succesfuly
 277 *
 278 */
 279 eCL2_RESULT cl2_init_card
 280         (
 281         sCAN_CARD *card,            /* Pointer to card structure */
 282         void *baseAddress,          /* Card base address pointer */
 283         U16 intNumber               /* Card interrupt number */
 284         );
 285
 286
 287 /*******************************************************************************
 288 * cl2_test_card - test card
 289 * """""""""""""
 290 *
 291 * Test whether the card is installed in system and working properly
 292 * or not. If this function fails (return value is CL2_HW_FAILURE)
 293 * check if the card is present and card base address.
 294 *
 295 * RETURNS:
 296 *   CL2_OK - card is present and working properly
 297 *   CL2_HW_FAILURE - card not found or card error
 298 *
 299 */
 300 eCL2_RESULT cl2_test_card
 301         (
 302         sCAN_CARD *card           /* Pointer to card structure */
 303         );
 304
 305
 306 /*******************************************************************************
 307 * cl2_reset_card - reset card
 308 * """"""""""""""
 309 *
 310 * Card pointed by *card gets hardware reset. This command resets
 311 * card processor, card settings are restored to their default
 312 * values.
 313 *
 314 * RETURNS:
 315 *   CL2_OK - command completed successfuly
 316 *
 317 */
 318 eCL2_RESULT cl2_reset_card
 319    (
 320    sCAN_CARD *card             /* Pointer to card structure */
 321    );
 322
 323
 324 /*******************************************************************************
 325 * cl2_get_version - read card version
 326 * """""""""""""""
 327 *
 328 * Fucntion reads a value from card version register.
 329 *
 330 * RETURNS:
 331 *   CL2_OK - command completed successfuly
 332 *
 333 */
 334 eCL2_RESULT cl2_get_version
 335    (
 336    sCAN_CARD *card,            /* Pointer to card structure */
 337    U16 *version                /* returns card version */
 338    );
 339
 340
 341 /*******************************************************************************
 342 * cl2_get_ID - read card ID
 343 * """""""""""""""
 344 *
 345 * Fucntion reads a value from card ID register.
 346 *
 347 * RETURNS:
 348 *   CL2_OK - command completed successfuly
 349 *
 350 */
 351 eCL2_RESULT cl2_get_ID
 352    (
 353    sCAN_CARD *card,            /* Pointer to card structure */
 354    U32 *IDlow,
 355    U32 *IDhigh                         /* returns card version */
 356    );
 357
 358
 359 /*******************************************************************************
 360 * cl2_gen_interrupt - request for interrupt
 361 * """""""""""""""""
 362 *
 363 * CAN card is requested to generate interrupt if there is any reason
 364 * to do it. The condition for interrupt generation is defined by
 365 * cl2_int_mode command.
 366 *
 367 * RETURNS:
 368 *   CL2_OK - command completed successfuly
 369 *
 370 */
 371 eCL2_RESULT cl2_gen_interrupt
 372    (
 373    sCAN_CARD *card           /* Pointer to card structure */
 374    );
 375
 376
 377 /*******************************************************************************
 378 * cl2_start_it - start inhibit time
 379 * """"""""""""
 380 *
 381 * Command starts interrupt inhibit time. If there is any reason for
 382 * interrupt geneation, the card generates interrupt after end of
 383 * specified time interval. Time interval is set by cl2_set_iit command.
 384 *
 385 * RETURNS:
 386 *   CL2_OK - command completed successfuly
 387 *
 388 */
 389 eCL2_RESULT cl2_start_it
 390    (
 391    sCAN_CARD *card           /* Pointer to card structure */
 392    );
 393
 394
 395 /*******************************************************************************
 396 * cl2_clear_interrupt - clear interrupt
 397 * """""""""""""""""""
 398 *
 399 * Comand clears interrupt (IRQ) generated by a card.
 400 *
 401 * RETURNS:
 402 *   CL2_OK - command completed successfuly
 403 *
 404 */
 405 eCL2_RESULT cl2_clear_interrupt
 406    (
 407    sCAN_CARD *card          /* Pointer to card structure */
 408    );
 409
 410
 411 /*******************************************************************************
 412 * cl2_int_mode - set interrupt mode
 413 * """"""""""""
 414 *
 415 * Command controls, which event will generate interrupt. Constants
 416 * CL2_INT_XXXX are used for setting of interrupt mode.
 417 *
 418 * RETURNS:
 419 *   CL2_OK - command completed successfuly
 420 *   CL2_BAD_PARAM - bad command parameter
 421 *   CL2_COMMAND_BUSY - previous command not completed
 422 *
 423 */
 424 eCL2_RESULT cl2_int_mode
 425    (
 426    sCAN_CARD *card,            /* Pointer to card structure */
 427    U16 mode                    /* Interrupt mode */
 428    );
 429
 430
 431 /*******************************************************************************
 432 * cl2_iit_mode - inhibit interrupt time mode
 433 * """"""""""""
 434 *
 435 * Command enables/disables inhibit interupt time mode.
 436 *
 437 * RETURNS:
 438 *   CL2_OK - command completed successfuly
 439 *   CL2_COMMAND_BUSY - previous command not completed
 440 *
 441 */
 442 eCL2_RESULT cl2_iit_mode
 443    (
 444    sCAN_CARD *card,            /* Pointer to card structure */
 445    BOOLEAN1 onoff              /* IIT mode - TRUE=on, FALSE=off */
 446    );
 447
 448
 449 /*******************************************************************************
 450 * cl2_sync_mode - sync mode
 451 * """""""""""""
 452 *
 453 * Command enables/disables transmission of SYNC frames.
 454 *
 455 * RETURNS:
 456 *   CL2_OK - command completed successfuly
 457 *   CL2_COMMAND_BUSY - previous command not completed
 458 *
 459 */
 460 eCL2_RESULT cl2_sync_mode
 461    (
 462    sCAN_CARD *card,            /* Pointer to card structure */
 463    BOOLEAN1 onoff              /* Sync mode - TRUE=on, FALSE=off */
 464    );
 465
 466
 467 /*******************************************************************************
 468 * cl2_rtr_mode - rtr mode
 469 * """"""""""""
 470 *
 471 * Command enables/disables automatic transmission of RTR frames
 472 *
 473 * RETURNS:
 474 *   CL2_OK - command completed successfuly
 475 *   CL2_COMMAND_BUSY - previous command not completed
 476 *
 477 */
 478 eCL2_RESULT cl2_rtr_mode
 479    (
 480    sCAN_CARD *card,            /* Pointer to card structure */
 481    BOOLEAN1 onoff              /* RTR mode - TRUE=on, FALSE=off */
 482    );
 483
 484
 485 /*******************************************************************************
 486 * cl2_buf_size - size of synchronous queue
 487 * """"""""""""
 488 *
 489 * Command sets the size of synchronous send buffer. The size is
 490 * in numbers of messages. Default buffer size is 32 messages.
 491 * The sum of synchronous_buffer_size and asynchronous_buffer_size
 492 * is constant and equal to 64. So, if the size od synchronous
 493 * buffer increases, the size of asynchronous buffer decreases and
 494 * vice versa.
 495 * NOTE: 1 message = 16 bytes
 496 *
 497 * RETURNS:
 498 *   CL2_OK - command completed successfully
 499 *   CL2_COMMAND_BUSY - previous command not completed
 500 *   CL2_BAD_PARAM - bad command parameter (bufSize>64)
 501 *
 502 */
 503 eCL2_RESULT cl2_buf_size
 504    (
 505    sCAN_CARD *card,            /* Pointer to card structure */
 506    U16 bufSize                 /* Size of synchronous buffer */
 507    );
 508
 509
 510 /*******************************************************************************
 511 * cl2_set_iit - set value of inhibit interrupt time
 512 * """""""""""
 513 *
 514 * Command sets value of inhibit interrupt time. If inhibit
 515 * interrupt time mode is enabled and started, generation of
 516 * interrupt (IRQ) is disabled during this time period.
 517 * Inhibit interrupt time can be set from 100 us to 6.5535 s
 518 *
 519 * RETURNS:
 520 *   CL2_OK - command completed successfuly
 521 *   CL2_COMMAND_BUSY - previous command not completed
 522 *
 523 */
 524 eCL2_RESULT cl2_set_iit
 525    (
 526    sCAN_CARD *card,            /* Pointer to card structure */
 527    U16 iit                     /* time period in x100 us */
 528    );
 529
 530
 531 /*******************************************************************************
 532 * cl2_start_firmware - start firmware
 533 * """"""""""""""""""
 534 *
 535 * Command starts card firmware
 536 *
 537 * RETURNS:
 538 *   CL2_OK - command completed successfuly
 539 *   CL2_COMMAND_BUSY - previous command not completed
 540 *
 541 */
 542 eCL2_RESULT cl2_start_firmware
 543    (
 544    sCAN_CARD *card             /* Pointer to card structure */
 545    );
 546
 547
 548 /*******************************************************************************
 549 * cl2_set_rec_mode - set receive mode
 550 * """"""""""""""""
 551 *
 552 * Command sets card receive mode. This enable reception of standard
 553 * or extended frames according to CAN 2.0A and 2.0B specifications.
 554 * If value of mode is TRUE, card receives extended frames, if mode
 555 * is FALSE, card receives standard massage format (default).
 556 *
 557 * RETURNS:
 558 *   CL2_OK - command completed successfuly
 559 *   CL2_COMMAND_BUSY - previous command not completed
 560 *
 561 */
 562 eCL2_RESULT cl2_set_rec_mode
 563    (
 564    sCAN_CARD *card,           /* Pointer to card structure */
 565    BOOLEAN1 mode              /* Mode - TRUE=ext, FALSE=std */
 566    );
 567
 568
 569 /*******************************************************************************
 570 * cl2_clr_rx_buffer - clear RX buffer
 571 * """""""""""""""""
 572 *
 573 * Command clears receive (rx) buffer. All messages stored in
 574 * rx buffer will be lost.
 575 *
 576 * RETURNS:
 577 *   CL2_OK - command completed successfuly
 578 *   CL2_COMMAND_BUSY - previous command not completed
 579 *
 580 */
 581 eCL2_RESULT cl2_clr_rx_buffer
 582    (
 583    sCAN_CARD *card            /* Pointer to card structure */
 584    );
 585
 586
 587 /*******************************************************************************
 588 * cl2_clr_sync_buffer - clear synchronous buffer
 589 * """""""""""""""""""
 590 *
 591 * Command clears synchronous send buffer. All messages stored
 592 * in synchronous buffer will be lost.
 593 *
 594 * RETURNS:
 595 *   CL2_OK - command completed successfuly
 596 *   CL2_COMMAND_BUSY - previous command not completed
 597 *
 598 */
 599 eCL2_RESULT cl2_clr_sync_buffer
 600    (
 601    sCAN_CARD *card             /* Pointer to card structure */
 602    );
 603
 604
 605 /*******************************************************************************
 606 * cl2_clr_async_buffer - clear asynchronous buffer
 607 * """"""""""""""""""""
 608 *
 609 * Command clears asynchronnous send buffer. All messages stored
 610 * in async buffer will be lost.
 611 *
 612 * RETURNS:
 613 *   CL2_OK - command completed successfuly
 614 *   CL2_COMMAND_BUSY - previous command not completed
 615 *
 616 */
 617 eCL2_RESULT cl2_clr_async_buffer
 618    (
 619    sCAN_CARD *card            /* Pointer to card structure */
 620    );
 621
 622
 623 /*******************************************************************************
 624 * cl2_send_time_sync - send time synchronization
 625 * """"""""""""""""""
 626 *
 627 * Command forces the card to start the High Resolution Synchronization
 628 * Protocol according to the CANopen Communication profile. The SYNC
 629 * mode has to be enabled (cl2_sync_mode) otherwise this command has
 630 * no effect.
 631 *
 632 * RETURNS:
 633 *   CL2_OK - command completed successfuly
 634 *   CL2_COMMAND_BUSY - previous command not completed
 635 *
 636 */
 637 eCL2_RESULT cl2_send_time_sync
 638    (
 639    sCAN_CARD *card             /* Pointer to card structure */
 640    );
 641
 642
 643 /*******************************************************************************
 644 * cl2_set_time_cobid - set time COB-ID
 645 * """"""""""""""""""
 646 *
 647 * Command sets the COB-ID for high resolution synchronization
 648 * frame. The synchronization can be then made by means of
 649 * cl2_send_time_sync command.
 650 *
 651 * RETURNS:
 652 *   CL2_OK - command completed successfuly
 653 *   CL2_COMMAND_BUSY - previous command not completed
 654 *
 655 */
 656 eCL2_RESULT cl2_set_time_cobid
 657    (
 658    sCAN_CARD *card,           /* Pointer to card structure */
 659    U32 COBID                  /* HRS frame COB-ID */
 660    );
 661
 662
 663 /*******************************************************************************
 664 * cl2_set_receive_limit - set limit for receive signaling
 665 * """""""""""""""""""""
 666 *
 667 * Command is used to set the receive limit signalized by bit
 668 * RL (in CL2.H CL2_X_DATA_IN_RBUF) of the Status Register.
 669 * This bit is set when more then the limit number of frames
 670 * was received since the last interrupt was generated (in interrupt
 671 * mode) or since the Status Register was last time read.
 672 *
 673 * RETURNS:
 674 *   CL2_OK
 675 *   CL2_COMMAND_BUSY - previous command not completed
 676 *   CL2_BAD_PARAM - bad command parameter
 677 */
 678 eCL2_RESULT cl2_set_receive_limit
 679    (
 680    sCAN_CARD *card,          /* pointer to card structure */
 681    U16 limit                 /* limit of messages in receive buffer */
 682    );
 683
 684
 685 /*******************************************************************************
 686 * cl2_download_rtr_list - download rtr list
 687 * """""""""""""""""""""
 688 *
 689 * Command downloads a list of up to 64 RTR frames. These frames are
 690 * periodically transmitted by the card. The parameters, how often
 691 * frames are send and in which SYNC period is defined by period and
 692 * subperiod in sRTR_FRAME structure.
 693 *
 694 * RETURNS:
 695 *   CL2_OK - command completed successfuly
 696 *   CL2_COMMAND_BUSY - previous command not completed
 697 *   CL2_BAD_PARAM - bad command parameter
 698 *
 699 */
 700 eCL2_RESULT cl2_download_rtr_list
 701    (
 702    sCAN_CARD *card,           /* Pointer to card structure */
 703    sRTR_LIST *rtrList         /* RTR list */
 704    );
 705
 706
 707 /*******************************************************************************
 708 * cl2_subscribe_rtr - subscribe RTR frame
 709 * """""""""""""""""
 710 *
 711 * Command subscribes RTR frame. Incoming RTR frames which were
 712 * subscribed are accepted, while other are ignored. Up to 10
 713 * RTR frames can be subscribed.
 714 *
 715 * RETURNS:
 716 *   CL2_OK - command completed successfuly
 717 *   CL2_COMMAND_BUSY - previous command not completed
 718 *   CL2_BAD_PARAM - bad command parameter
 719 *
 720 */
 721 eCL2_RESULT cl2_subscribe_rtr
 722    (
 723    sCAN_CARD *card,            /* Pointer to card structure */
 724    sCAN_MESSAGE *canMessage,   /* RTR frame */
 725    U16 RTRnumber               /* number of RTR */
 726    );
 727
 728
 729 /*******************************************************************************
 730 * cl2_desubscribe_rtr - desubscribe rtr frame
 731 * """""""""""""""""""
 732 *
 733 * Command desubscribes RTR frame. Card will not accept RTR frames
 734 * with this identifier.
 735 *
 736 * RETURNS:
 737 *   CL2_OK - command completed successfuly
 738 *   CL2_COMMAND_BUSY - previous command not completed
 739 *   CL2_BAD_PARAM - bad command parameter
 740 *
 741 */
 742 eCL2_RESULT cl2_desubscribe_rtr
 743    (
 744    sCAN_CARD *card,            /* Pointer to card structure */
 745    sCAN_MESSAGE *canMessage    /* RTR frame */
 746    );
 747
 748
 749 /*******************************************************************************
 750 * cl2_set_sync_cobid - set COB-ID
 751 * """"""""""""""""""
 752 *
 753 * Command sets COB-ID of SYNC frame. In active SYNC mode, the SYNC
 754 * frame with this COB-ID is periodically sent with period defined
 755 * by cl2_set_sync_period command.
 756 *
 757 * RETURNS:
 758 *   CL2_OK - command completed successfuly
 759 *   CL2_COMMAND_BUSY - previous command not completed
 760 *
 761 */
 762 eCL2_RESULT cl2_set_sync_cobid
 763    (
 764    sCAN_CARD *card,            /* Pointer to card structure */
 765    U32 COBID                   /* COB-ID */
 766    );
 767
 768
 769 /*******************************************************************************
 770 * cl2_set_sync_period - set SYNC period
 771 * """""""""""""""""""
 772 *
 773 * Coomand sets the SYNC frame send period in active SYNC mode in
 774 * x100 us. The period range is from 0 to 0xFFFF (SYNC period can
 775 * be set from 100us to 6.5535s).
 776 *
 777 * RETURNS:
 778 *   CL2_OK - command completed successfuly
 779 *   CL2_COMMAND_BUSY - previous command not completed
 780 *
 781 */
 782 eCL2_RESULT cl2_set_sync_period
 783    (
 784    sCAN_CARD *card,            /* Pointer to card structure */
 785    U16 period                  /* period in x100 us */
 786    );
 787
 788
 789 /*******************************************************************************
 790 * cl2_set_sync_window - set SYNC window
 791 * """""""""""""""""""
 792 *
 793 * Command sets the SYNC window length. Only during this time period
 794 * after SYNC frame was send or receive the frames from the synchronous
 795 * send buffer can be sent.
 796 *
 797 * RETURNS:
 798 *   CL2_OK - command completed successfuly
 799 *   CL2_COMMAND_BUSY - previous command not completed
 800 *
 801 */
 802 eCL2_RESULT cl2_set_sync_window
 803    (
 804    sCAN_CARD *card,            /* Pointer to card structure */
 805    U16 window                  /* period in x100 us */
 806    );
 807
 808
 809 /*******************************************************************************
 810 * cl2_set_bitrate - set CAN bit-rate
 811 * """""""""""""""
 812 *
 813 * Command switches the bus bit-rate. There are some predefined
 814 * constants CL2_BITRATE_XXXX.
 815 *
 816 * RETURNS:
 817 *   CL2_OK - command completed successfuly
 818 *   CL2_COMMAND_BUSY - previous command not completed
 819 *
 820 */
 821 eCL2_RESULT cl2_set_bitrate
 822    (
 823    sCAN_CARD *card,            /* Pointer to card structure */
 824    U16 bitrate                 /* CAN bitrate */
 825    );
 826
 827
 828 /*******************************************************************************
 829 * cl2_bus_reset - resets CAN controller
 830 * """""""""""""
 831 *
 832 * Command resets CAN controller
 833 *
 834 * RETURNS:
 835 *   CL2_OK - command completed successfuly
 836 *   CL2_COMMAND_BUSY - previously command not completed
 837 *
 838 */
 839 eCL2_RESULT cl2_bus_reset
 840    (
 841    sCAN_CARD *card            /* Pointer to card structure */
 842    );
 843
 844
 845 /*******************************************************************************
 846 * cl2_send_sync - sends synchronous frame
 847 * """""""""""""
 848 *
 849 * Command stores massage in synchronous send buffer.
 850 *
 851 * RETURNS:
 852 *   CL2_OK - command completed successfuly
 853 *   CL2_HW_QUEUE_FULL - synchronous send buffer is full
 854 *   CL2_BAD_PARAM - bad command parameter
 855 *   CL2_HW_FAILURE - error in HW configuration
 856 *
 857 */
 858 eCL2_RESULT cl2_send_sync
 859    (
 860    sCAN_CARD *card,           /* Pointer to card structure */
 861    sCAN_MESSAGE *message      /* message to be sent */
 862    );
 863
 864
 865 /*******************************************************************************
 866 * cl2_send_async - sends asynchronous frame
 867 * """"""""""""""
 868 *
 869 * Command stores message in asynchronous send buffer.
 870 *
 871 * RETURNS:
 872 *   CL2_OK - command completed successfuly
 873 *   CL2_HW_QUEUE_FULL - asynchronous buffer full
 874 *   CL2_HW_FAILURE - error in HW configuration
 875 *   CL2_BAD_PARAM - bad command parameter
 876 *
 877 */
 878 eCL2_RESULT cl2_send_async
 879    (
 880    sCAN_CARD *card,           /* Pointer to card structure */
 881    sCAN_MESSAGE *message      /* message */
 882    );
 883
 884
 885 /*******************************************************************************
 886 * cl2_get_status - reads card status
 887 * """"""""""""""
 888 *
 889 * Command reads card status register. If data in status register
 890 * are valid (status valid flag is set), the value of status is read
 891 * and stored in status and sCAN_CARD structure.
 892 *
 893 * RETURNS:
 894 *   CL2_OK - command completed successfuly
 895 *   CL2_NO_REQUEST - status is not valid
 896 *
 897 */
 898 eCL2_RESULT cl2_get_status
 899    (
 900    sCAN_CARD *card,           /* Pointer to card structure */
 901    U16 *status                /* Returned status */
 902    );
 903
 904
 905 /*******************************************************************************
 906 * cl2_get_error - reads card error
 907 * """""""""""""
 908 *
 909 * Command reads card error register. If data in error register
 910 * are valid (error register valid flag is set), the value of error
 911 * register is read and stored in error and sCAN_CARD structure.
 912 *
 913 * RETURNS:
 914 *   Cl2_OK - command completed successfuly
 915 *
 916 */
 917 eCL2_RESULT cl2_get_error
 918    (
 919    sCAN_CARD *card,           /* Pointer to card structure */
 920    U16 *error                 /* Returned card error code */
 921    );
 922
 923
 924 /*******************************************************************************
 925 * cl2_receive_data - reads received frame
 926 * """"""""""""""""
 927 *
 928 * Command reads new messages received by a card.
 929 *
 930 * RETURNS:
 931 *   CL2_OK - command commpleted successfuly
 932 *   CL2_NO_REQUEST - there is no new message
 933 *
 934 */
 935 eCL2_RESULT cl2_receive_data
 936    (
 937    sCAN_CARD *card,             /* Pointer to card structure */
 938    sCAN_MESSAGE *canMessage     /* Message */
 939    );
 940
 941
 942 /* *********************************************************************** *
 943  * END OF CL2.H                                                            *
 944  * *********************************************************************** */
 945
 946 #endif /* ifndef __INC_CL2_H */