开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 能源行业(电力石油煤炭) > 查看源码
dp_if.c
资源名称：Profibus.rar　[点击查看]
上传用户：hualang
上传日期：2022-04-11
资源大小：104k
文件大小：73k
源码类别：

能源行业(电力石油煤炭)

开发平台：

C/C++

dp_if.c：源码内容
  1. /***********************  Filename: dp_if.c  *********************************/
  2. /* ========================================================================= */
  3. /*                                                                           */
  4. /* 0000  000   000  00000 0  000  0   0 0 0000                               */
  5. /* 0   0 0  0 0   0 0     0 0   0 0   0 0 0   0                              */
  6. /* 0   0 0  0 0   0 0     0 0     0   0 0 0   0      Einsteinstra遝 6        */
  7. /* 0000  000  0   0 000   0 0     00000 0 0000       91074 Herzogenaurach    */
  8. /* 0     00   0   0 0     0 0     0   0 0 0                                  */
  9. /* 0     0 0  0   0 0     0 0   0 0   0 0 0          Tel: ++49-9132-744-200  */
  10. /* 0     0  0  000  0     0  000  0   0 0 0    GmbH  Fax: ++49-9132-744-204  */
  11. /*                                                                           */
  12. /* ========================================================================= */
  13. /*                                                                           */
  14. /* Function:       interface service routines for VPC3+ (dp-protocol)        */
  15. /*                                                                           */
  16. /* ------------------------------------------------------------------------- */
  17. /* history                                                                   */
  18. /* ========================================================================= */
  19. /* 08.09.2005 [V5.00]  Urversion                                             */
  20. /* 22.10.2005 [V5.01]  BugFix:                                               */
  21. /*                     Dp_cfg.h:                                             */
  22. /*                     Missing bracket:                                      */
  23. /*                     #define ASIC_USER_RAM (ASIC_RAM_LENGTH -              */
  24. /*                                              DP_ORG_LENGTH - SAP_LENGTH)  */
  25. /*                                                                           */
  26. /* ------------------------------------------------------------------------- */
  27. /*                                                                           */
  28. /*                                                                           */
  29. /* Technical support:       P. Fredehorst                                    */
  30. /*                          Tel. : ++49-9132/744-214                         */
  31. /*                          Fax. :              -204                         */
  32. /*                          eMail: pfredehorst@profichip.com                 */
  33. /*                                                                           */
  34. /*****************************************************************************/
  37. /*****************************************************************************/
  38. /* contents:
  40.   - function prototypes
  41.   - data structures
  42.   - internal functions
  44. */
  45. /*****************************************************************************/
  46. /* include hierarchy */
  47. #include "..dp_incplatform.h"
  48. #include "..dp_incdp_inc.h"
  49. //#include "E5_Inc.h"
  50. //#include <cdefBF536.h>
  53. /*---------------------------------------------------------------------------*/
  54. /* version                                                                   */
  55. /*---------------------------------------------------------------------------*/
  56. #define DP_VERSION_MAIN_INTERFACE   ((UBYTE)0x05)
  57. #define DP_VERSION_FUNCTION         ((UBYTE)0x00)
  58. #define DP_VERSION_BUGFIX           ((UBYTE)0x01)
  60. /*---------------------------------------------------------------------------*/
  61. /* function prototypes                                                       */
  62. /*---------------------------------------------------------------------------*/
  63. DP_ERROR_CODE   vpc3_set_constants  (UBYTE dev_num, UBYTE slave_address );
  64. DP_ERROR_CODE   ssc_init            (UBYTE dev_num);
  65. DP_ERROR_CODE   vpc3_buf_init       (UBYTE dev_num);
  66. UWORD           assign_aux_buf      (UBYTE dev_num, UWORD PTR_ATTR *lens, UBYTE count, UBYTE PTR_ATTR *assign, UWORD PTR_ATTR *aux_len );
  68. /*---------------------------------------------------------------------------*/
  69. /* global user data definitions                                              */
  70. /*---------------------------------------------------------------------------*/
  71. SECTION_DEF_CommuData VPC3_STRUC          VPC3_PTR    p_Vpc3[MAX_DEV_NUM];     // pointer to Vpc3 structure
  72. SECTION_DEF_CommuData VPC3_SYSTEM_STRUC               dp_sys[MAX_DEV_NUM];     // global system structure
  74. #ifdef DP_DEBUG_ENABLE
  75. SECTION_DEF_CommuData     sDP_DEBUG_BUFFER_ITEM   asDebugBuffer[MAX_DEV_NUM][ MAX_NR_OF_DEBUG ];
  76. SECTION_DEF_CommuData     UBYTE                   bDebugBufferIndex[MAX_DEV_NUM];
  77. SECTION_DEF_CommuData     UBYTE                   bDebugBufferOverlapped[MAX_DEV_NUM];
  78. #endif//#ifdef DP_DEBUG_ENABLE
  80. /*---------------------------------------------------------------------------*/
  81. /* defines                                                                   */
  82. /*---------------------------------------------------------------------------*/
  83. /* Literals */
  84. /* Lage der Bits der AUX-Puffer-Zuordnung */
  85. #define RBL_PRM                 0
  86. #define RBL_CFG                 1
  87. #define RBL_SSA                 2
  89. /*---------------------------------------------------------------------------*/
  90. /* function: DP_GetVersion                                                   */
  91. /*---------------------------------------------------------------------------*/
  92. SECTION_DEF_CommuCode void DP_GetVersion(UBYTE dev_num, psDP_VERSION pVersion )
  93. {
  94.     pVersion->wComponentsInstalled =    0x0000
  96.                             #ifdef DP_MSAC_C1
  97.                                        | DP_COMP_INSTALLED_MSAC1_IFA
  99.                                 #ifdef DP_ALARM
  100.                                        | DP_COMP_INSTALLED_SUB_AL
  101.                                      #ifdef DP_ALARM_OVER_SAP50
  102.                                        | DP_COMP_INSTALLED_SUB_AL_50
  103.                                      #endif//DP_ALARM_OVER_SAP50
  104.                                 #endif//#ifdef DP_ALARM
  106.                                 #ifdef DPV1_IM_SUPP
  107.                                        | DP_COMP_INSTALLED_IM
  108.                                 #endif//#ifdef DPV1_IM_SUPP
  109.                             #endif//#ifdef DP_MSAC_C1
  111.                             #ifdef DP_MSAC_C2
  112.                                        | DP_COMP_INSTALLED_MSAC2_IFA
  114.                                 #ifdef DPV1_IM_SUPP
  115.                                        | DP_COMP_INSTALLED_IM
  116.                                 #endif//#ifdef DPV1_IM_SUPP
  117.                             #endif//#ifdef DP_MSAC_C2
  119.                                         ;
  121.     switch(VPC3_GET_ASIC_TYPE(dev_num) )
  122.     {
  123.         case AT_VPC3B:
  124.         {
  125.             pVersion->wComponentsInstalled |= DP_COMP_INSTALLED_VPC3_B ;
  126.             break;
  127.         }
  129.         case AT_VPC3C:
  130.         {
  131.             pVersion->wComponentsInstalled |= DP_COMP_INSTALLED_VPC3_C ;
  132.             break;
  133.         }
  135.         case AT_MPI12X:
  136.         {
  137.             pVersion->wComponentsInstalled |= DP_COMP_INSTALLED_VPC3_D ;
  138.             break;
  139.         }
  141.         default:
  142.         {
  143.             //do nothing
  144.         }
  145.     }//switch(VPC3_GET_ASIC_TYPE(dev_num)
  148.     pVersion->bMainInterface = DP_VERSION_MAIN_INTERFACE;
  149.     pVersion->bFunction      = DP_VERSION_FUNCTION;
  150.     pVersion->bBugfix        = DP_VERSION_BUGFIX;
  151. }//void DP_GetVersion(UBYTE dev_num, psDP_VERSION pVersion )
  153. /*---------------------------------------------------------------------------*/
  154. /* function: DP_WriteDebugBuffer                                             */
  155. /*---------------------------------------------------------------------------*/
  156. #ifdef DP_DEBUG_ENABLE
  157. SECTION_DEF_CommuCode void DP_WriteDebugBuffer(UBYTE dev_num, DEBUG_CODE bDebugCode, UBYTE bDetail1, UBYTE bDetail2 )
  158. {
  159.     asDebugBuffer[dev_num][ bDebugBufferIndex[dev_num] ].bDebugCode = bDebugCode;
  160.     asDebugBuffer[dev_num][ bDebugBufferIndex[dev_num] ].bDetail1   = bDetail1;
  161.     asDebugBuffer[dev_num][ bDebugBufferIndex[dev_num] ].bDetail2   = bDetail2;
  163.     if( bDebugBufferIndex[dev_num] == (MAX_NR_OF_DEBUG-1) )
  164.     {
  165.         bDebugBufferOverlapped[dev_num] = TRUE;
  166.         bDebugBufferIndex[dev_num] = 0;
  167.     }
  168.     else
  169.     {
  170.         bDebugBufferIndex[dev_num]++;
  171.     }
  172. }//void DP_WriteDebugBuffer(UBYTE dev_num, DEBUG_CODE debug_code, UBYTE detail_1, UBYTE detail_2 )
  173. #endif//#ifdef DP_DEBUG_ENABLE
  175. /*---------------------------------------------------------------------------*/
  176. /* function: DP_ClearDebugBuffer                                             */
  177. /*---------------------------------------------------------------------------*/
  178. #ifdef DP_DEBUG_ENABLE
  179. SECTION_DEF_CommuCode void DP_ClearDebugBuffer(dev_num)
  180. {
  181. UWORD i;
  183.     bDebugBufferOverlapped[dev_num] = FALSE;
  184.     bDebugBufferIndex[dev_num]      = 0x00;
  186.     for(i = 0; i < MAX_NR_OF_DEBUG; i++ )
  187.     {
  188.         asDebugBuffer[dev_num][i].bDebugCode = 0x00;
  189.         asDebugBuffer[dev_num][i].bDetail1   = 0x00;
  190.         asDebugBuffer[dev_num][i].bDetail2   = 0x00;
  191.     }//for( i = 0; i < MAX_NR_OF_DEBUG; i++ )
  192. }//void DP_ClearDebugBuffer(dev_num)
  193. #endif//#ifdef DP_DEBUG_ENABLE
  195. /*--------------------------------------------------------------------------*/
  196. /*vpc3 reset function                                                       -*/
  197. /*--------------------------------------------------------------------------*/
  198. extern void ResetVPC3_0(void);
  200. SECTION_DEF_CommuCode void ResetVPC3(UBYTE dev_num)
  201. {
  202. if(dev_num == NET_A)
  203. {
  204. ResetVPC3_0();
  205. }
  206. else if(dev_num == NET_B)
  207. {
  209. }
  210. }
  212. /*---------------------------------------------------------------------------*/
  213. /*                                                                           */
  214. /*  UBYTE vpc3_initialization ()                                             */
  215. /*                                                                           */
  216. /*   function:     initializing the vpc3+ controller                         */
  217. /*                                                                           */
  218. /*   parameter:    VPC3_INIT, VPC3_DP_INIT                                   */
  219. /*   return value: errorcode (0 = no error)                                  */
  220. /*                                                                           */
  221. /*---------------------------------------------------------------------------*/
  222. SECTION_DEF_CommuCode DP_ERROR_CODE vpc3_initialization(UBYTE dev_num, UBYTE slave_address, CFG_STRUCT cfg )
  223. {
  224. DP_ERROR_CODE       error;
  225. BLACKFIN_WORDPTR  vpc3_ptr;       // pointer to vpc3 memory area
  226. unsigned char       j;
  227. UWORD               i;
  228. int nBlackfinLoop;
  229. BLACKFINDATATYPE* pBlackfinAddr;
  231.     /*-----------------------------------------------------------------------*/
  232.     /* initialize global system structure                                    */
  233.     /*-----------------------------------------------------------------------*/
  234.     memset(&dp_sys[dev_num], 0, sizeof(dp_sys[dev_num]));
  236.     #ifdef DP_DEBUG_ENABLE
  237.         DP_ClearDebugBuffer(dev_num);
  238.     #endif//#ifdef DP_DEBUG_ENABLE
  240.     /*-----------------------------------------------------------------------*/
  241.     /* init vpc3 data                                                        */
  242.     /*-----------------------------------------------------------------------*/
  243.     p_Vpc3[dev_num] = (VPC3_STRUC VPC3_PTR)VPC3_ASIC_ADDRESS(dev_num);//设置vpc的基本地址
  245.     //VPC3_CLEAR_RESET__;
  246.     //NOP__();
  248.     #ifdef MPI12x
  249.         p_Vpc3[dev_num]->int_req1 = 0x03;
  250.         NOP__();
  251.         NOP__();
  252.         NOP__();
  253.         NOP__();
  254.     #endif//#ifdef MPI12x
  256.     //neccessary, if 4Kbyte mode enabled
  257.     p_Vpc3[dev_num]->ctrl_reg.wr.mode_reg2 = INIT_VPC3_MODE_REG_2;
  258.     
  259.     
  260. //    DELAY_TICK(1);
  261.     
  262.     /*-----------------------------------------------------------------------*/
  263.     /* test and clear vpc3 ram                                               */
  264.     /*-----------------------------------------------------------------------*/
  265.     error = DP_OK;
  267.     j = 0;
  268.     vpc3_ptr = &p_Vpc3[dev_num]->slave_addr;
  269.     for(i = 0x16; i < ASIC_RAM_LENGTH;)
  270.     {
  271.         *((BLACKFINDATATYPE*)vpc3_ptr)=j;
  272.         i++;
  273.         j++;
  274.         vpc3_ptr+=1;
  275.     }
  278.     j = 0;
  279.     vpc3_ptr = &p_Vpc3[dev_num]->slave_addr;
  280.     for(i = 0x16; i < ASIC_RAM_LENGTH;)
  281.     {
  282.         if( (*((BLACKFINDATATYPE*)vpc3_ptr)&0xFF)  != (j&0xFF) )
  283.         {
  284.           error = DP_VPC3_ERROR; // ERROR
  285.           break;
  286.         }
  287.         i++;
  288.         j++;
  289.         vpc3_ptr+=1;
  290.     }
  293.     if(DP_OK == error)
  294.     {
  295.         //clear VPC3
  296.         memset(&p_Vpc3[dev_num]->slave_addr, 0, (ASIC_RAM_LENGTH-0x16)*BLACKFIN_MULTIPLER );
  298.         /*-------------------------------------------------------------------*/
  299.         /* check VPC3 is in OFFLINE                                          */
  300.         /*-------------------------------------------------------------------*/
  301.         if( !VPC3_GET_OFF_PASS(dev_num) )
  302.         {
  303.             /*---------------------------------------------------------------*/
  304.             /* set constant values                                           */
  305.             /*---------------------------------------------------------------*/
  306.             error = vpc3_set_constants(dev_num, slave_address );
  307.             if(DP_OK == error)
  308.             {
  309.                 /*-----------------------------------------------------------*/
  310.                 /* calculate length of input and output data using cfg-data  */
  311.                 /*-----------------------------------------------------------*/
  312.                 error = vpc3_calculate_inp_outp_len (dev_num, &cfg.cfg_data[0], cfg.length);
  313.                 if( DP_OK == error )
  314.                 {
  315.                     /*-------------------------------------------------------*/
  316.                     /* initialize buffer structure                           */
  317.                     /*-------------------------------------------------------*/
  318.                     error = vpc3_buf_init(dev_num);
  319.                     if (DP_OK == error)
  320.                     {
  321.                         /*---------------------------------------------------*/
  322.                         /* set real configuration data                       */
  323.                         /*---------------------------------------------------*/
  324.                         VPC3_SET_READ_CFG_LEN(dev_num,cfg.length);      // set configuration length
  325.                         //memcpy(VPC3_GET_READ_CFG_BUF_PTR(dev_num), &cfg.cfg_data[0], cfg.length );
  326. pBlackfinAddr = (BLACKFINDATATYPE*)VPC3_GET_READ_CFG_BUF_PTR(dev_num);
  327. for (nBlackfinLoop=0; nBlackfinLoop<cfg.length; nBlackfinLoop++)
  328. {
  329. pBlackfinAddr[nBlackfinLoop] = cfg.cfg_data[nBlackfinLoop];
  330. }
  332.                         // set I/O length
  333.                         vpc3_set_io_data_len(dev_num);
  335.                         /*---------------------------------------------------*/
  336.                         /* initialize subscriber                             */
  337.                         /*---------------------------------------------------*/
  338.                         #ifdef DP_SUBSCRIBER
  339.                             error = ssc_init(dev_num);
  340.                         #endif//#ifdef DP_SUBSCRIBER
  342.                         /*---------------------------------------------------*/
  343.                         /* initialize fdl_interface                          */
  344.                         /*---------------------------------------------------*/
  345.                         #ifdef DP_FDL
  346.                             if(DP_OK == error)
  347.                             {
  348.                                 error = fdl_init(dev_num);
  350.                                 if(DP_OK == error)
  351.                                 {
  352.                                     /*-----------------------------------------------*/
  353.                                     /* initialize MSAC_C1                            */
  354.                                     /*-----------------------------------------------*/
  355.                                     #ifdef DP_MSAC_C1
  356.                                         error = msac_c1_init(dev_num);
  357.                                     #endif//#ifdef DP_MSAC_C1
  359.                                     #ifdef DP_MSAC_C2
  360.                                         if(DP_OK == error)
  361.                                         {
  362.                                             /*-------------------------------------------*/
  363.                                             /* initialize MSAC_C2                        */
  364.                                             /*-------------------------------------------*/
  365.                                             error = msac_c2_init(dev_num);
  366.                                         }
  367.                                     #endif//#ifdef DP_MSAC_C2
  368.                                 }
  369.                             }
  370.                         #endif //#ifdef DP_FDL
  371.                     }//if(DP_OK == error)
  372.                 }//if(DP_OK == error)
  373.             }//if(DP_OK == error)
  374.         }//if( !VPC3_GET_OFF_PASS(dev_num) )
  375.         else
  376.         {
  377.             error = DP_NOT_OFFLINE_ERROR;
  378.         }
  379.     }//if(DP_OK == error)
  380.     return error;
  381. }
  383. /*---------------------------------------------------------------------------*/
  384. /* function: START_VPC3                                                      */
  385. /*---------------------------------------------------------------------------*/
  386. SECTION_DEF_CommuCode void START_VPC3(UBYTE dev_num)
  387. {
  388.     /*-----------------------------------------------------------------------*/
  389.     /* start vpc3                                                            */
  390.     /*-----------------------------------------------------------------------*/
  391.     START_VPC3__(dev_num);
  393.     #ifdef DP_MSAC_C2
  394.         msac_c2_open_channel(dev_num);
  395.     #endif /* DP_MSAC_C2 */
  397.     // Fetch the first diagnosis buffer
  398.     dp_sys[dev_num].diag_buf_ptr.byte_ptr = vpc3_get_diagbufptr(dev_num);
  399. }//void START_VPC3(UBYTE dev_num)
  401. /*---------------------------------------------------------------------------*/
  402. /*                                                                           */
  403. /*   function:     initializing constant vpc3 values                         */
  404. /*                                                                           */
  405. /*---------------------------------------------------------------------------*/
  406. SECTION_DEF_CommuCode DP_ERROR_CODE vpc3_set_constants(UBYTE dev_num, UBYTE slave_address )
  407. {
  408. DP_ERROR_CODE error;
  410.     error = DP_OK;
  412.     dp_sys[dev_num].din_bufsize              = DIN_BUFSIZE;
  413.     dp_sys[dev_num].dout_bufsize             = DOUT_BUFSIZE;
  414.     dp_sys[dev_num].prm_bufsize              = PRM_BUFSIZE;
  415.     dp_sys[dev_num].diag_bufsize             = DIAG_BUFSIZE;
  416.     dp_sys[dev_num].cfg_bufsize              = CFG_BUFSIZE;
  417.     dp_sys[dev_num].ssa_bufsize              = SSA_BUFSIZE;
  419.     #ifdef DP_FDL
  420.         #ifdef DP_MSAC_C2
  421.             dp_sys[dev_num].c2_num_saps      = C2_NUM_SAPS;
  422.             dp_sys[dev_num].c2_len           = DP_C2_LEN;
  423.         #endif//#ifdef DP_MSAC_C2
  424.     #endif//#ifdef DP_FDL
  426.     /*-----------------------------------------------------------------------*/
  427.     /* initialize  control logic                                             */
  428.     /*-----------------------------------------------------------------------*/
  429.     p_Vpc3[dev_num]->int_req1                = 0x00;
  430.     p_Vpc3[dev_num]->int_req2                = 0x00;
  431.     p_Vpc3[dev_num]->isreg.wr.int_ack1       = 0xFF;
  432.     p_Vpc3[dev_num]->isreg.wr.int_ack2       = 0xFF;
  433.     p_Vpc3[dev_num]->ctrl_reg.wr.mode_reg1_r = 0xFF;      // reset mode register 1
  434.    
  435. p_Vpc3[dev_num]->ctrl_reg.wr.reserved_12 = 0;  // wusenlin
  437.     /*-----------------------------------------------------------------------*/
  438.     /* set modes of vpc3                                                     */
  439.     /*-----------------------------------------------------------------------*/
  440.     p_Vpc3[dev_num]->mode_reg0_H = INIT_VPC3_MODE_REG_H;
  441.     p_Vpc3[dev_num]->mode_reg0_L = INIT_VPC3_MODE_REG_L;
  444.     p_Vpc3[dev_num]->ctrl_reg.wr.mode_reg2 = INIT_VPC3_MODE_REG_2;
  446.     /*-----------------------------------------------------------------------*/
  447.     /* set interrupt triggers                                                */
  448.     /*-----------------------------------------------------------------------*/
  449.     p_Vpc3[dev_num]->isreg.wr.int_mask_H = (UBYTE) ~(INIT_VPC3_IND_H);
  450.     p_Vpc3[dev_num]->isreg.wr.int_mask_L = (UBYTE) ~(INIT_VPC3_IND_L);
  452.     dp_sys[dev_num].ind_high = (UBYTE) ~(INIT_VPC3_IND_H);
  453.     dp_sys[dev_num].ind_low  = (UBYTE) ~(INIT_VPC3_IND_L);
  455.     /*-----------------------------------------------------------------------*/
  456.     /* set time-variables                                                    */
  457.     /*-----------------------------------------------------------------------*/
  458.     p_Vpc3[dev_num]->ctrl_reg.wr.wd_baud_ctrl = 0x10;    // WD Timeout
  459.     p_Vpc3[dev_num]->ctrl_reg.wr.mintsdr      = 0x0B;    // Min Tsdr 11 BIT (11Bit .. 255Bit)
  461.     /*-----------------------------------------------------------------------*/
  462.     /* set variables for synch-mode                                          */
  463.     /*-----------------------------------------------------------------------*/
  464.     #ifdef ISOCHRON_MODE
  465.         p_Vpc3[dev_num]->ctrl_reg.wr.sync_pw_reg = SYNCH_PULSEWIDTH;   // sync pulse width register
  466.         p_Vpc3[dev_num]->ctrl_reg.wr.sync_group = 0x80;
  467.         p_Vpc3[dev_num]->ctrl_reg.wr.sync_mode  = 0x00;
  468.     #endif//#ifdef ISOCHRON_MODE
  470.     /*-----------------------------------------------------------------------*/
  471.     /* set user watchdog (dataexchange telegram counter)                     */
  472.     /*-----------------------------------------------------------------------*/
  473.     p_Vpc3[dev_num]->user_wd_value[1] = (UBYTE)(USER_WD >> 8);
  474.     p_Vpc3[dev_num]->user_wd_value[0] = (UBYTE)(USER_WD);
  476.     /*-----------------------------------------------------------------------*/
  477.     /* set pointer to FF                                                     */
  478.     /*-----------------------------------------------------------------------*/
  479.     p_Vpc3[dev_num]->fdl_sap_list_ptr = VPC3_SAP_CTRL_LIST_START(dev_num);
  480.     p_Vpc3[dev_num]->sap_ctrl_list[0] = 0xFF;
  482.     /*-----------------------------------------------------------------------*/
  483.     /* ssa support                                                           */
  484.     /*-----------------------------------------------------------------------*/
  485.     p_Vpc3[dev_num]->real_no_add_change = (dp_sys[dev_num].ssa_bufsize == 0 ) ? 0xFF : 0x00;
  487.     /*-----------------------------------------------------------------------*/
  488.     /* set profibus ident number                                             */
  489.     /*-----------------------------------------------------------------------*/
  490.     p_Vpc3[dev_num]->ident_high = (UBYTE)(IDENT_NR >> 8);
  491.     p_Vpc3[dev_num]->ident_low  = (UBYTE)(IDENT_NR);
  493.     /*-----------------------------------------------------------------------*/
  494.     /* set and check slave address                                           */
  495.     /*-----------------------------------------------------------------------*/
  496.      if( slave_address < 126 && slave_address != 0 )
  497.     {
  498.         p_Vpc3[dev_num]->slave_addr = slave_address;
  499.     }
  500.     else
  501.     {
  502.         error = DP_ADDRESS_ERROR;
  503.     }
  505.     return error;
  506. }
  509. /*---------------------------------------------------------------------------*/
  510. /*                                                                           */
  511. /*   function:     initializing subscriber                                   */
  512. /*                                                                           */
  513. /*---------------------------------------------------------------------------*/
  514. #ifdef DP_SUBSCRIBER
  515. SECTION_DEF_CommuCode DP_ERROR_CODE ssc_init(UBYTE dev_num)
  516. {
  517. DP_ERROR_CODE       error;
  518. BLACKFIN_WORDPTR  vpc3_ptr;           // pointer to VPC3, 礐ontroller formatted
  519. UBYTE               vpc3_seg_adr;       // segment address in VPC3-ASIC
  521.     error = DP_OK;
  523.     /*-----------------------------------------------------------------------*/
  524.     /* check buffer length                                                   */
  525.     /*-----------------------------------------------------------------------*/
  526.     if (DP_MAX_DATA_PER_LINK > 244)
  527.     {
  528.         error = SSC_MAX_DATA_PER_LINK;
  529.     }
  530.     else
  531.     {
  532.         // pointer mc formatted
  533.         vpc3_ptr = &p_Vpc3[dev_num]->dpbuffer[dp_sys[dev_num].vpc3_used_dp_buf_mem];
  534.         // pointer vpc3 formatted
  535.         vpc3_seg_adr = (UBYTE)(((VPC3_ADR)vpc3_ptr-(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num)) >> BLACKFIN_SEG_MULDIV );
  537.         // length dxb_out
  538.         p_Vpc3[dev_num]->len_dxb_out_buf = (((DP_MAX_DATA_PER_LINK+2)+SEG_OFFSET) & SEG_ADDBYTE);
  539.         dp_sys[dev_num].vpc3_used_dp_buf_mem += (3* BFWORD2BYTE(p_Vpc3[dev_num]->len_dxb_out_buf) );
  540.         // length link status
  541.         p_Vpc3[dev_num]->len_dxb_link_status_buf = ((((DP_MAX_LINK_SUPPORTED*2)+4)+SEG_OFFSET) & SEG_ADDBYTE);
  542.         dp_sys[dev_num].vpc3_used_dp_buf_mem += p_Vpc3[dev_num]->len_dxb_link_status_buf;
  543.         // length link table
  544.         p_Vpc3[dev_num]->len_dxb_link_table_buf = (((DP_MAX_LINK_SUPPORTED*4)+SEG_OFFSET) & SEG_ADDBYTE);
  545.         dp_sys[dev_num].vpc3_used_dp_buf_mem += p_Vpc3[dev_num]->len_dxb_link_table_buf;
  547.         /*-------------------------------------------------------------------*/
  548.         /* check memory consumption                                          */
  549.         /*-------------------------------------------------------------------*/
  550.         if( dp_sys[dev_num].vpc3_used_dp_buf_mem > sizeof (p_Vpc3[dev_num]->dpbuffer)/BLACKFIN_MULTIPLER )
  551.         {
  552.             // Error: user needs too much memory
  553.             dp_sys[dev_num].vpc3_used_dp_buf_mem = 0;
  554.             error = DP_LESS_MEM_ERROR;
  555.         }
  556.         else
  557.         {
  558.             /*---------------------------------------------------------------*/
  559.             /* set buffer pointer                                            */
  560.             /*---------------------------------------------------------------*/
  561.             p_Vpc3[dev_num]->dxb_link_table_buf_ptr  = vpc3_seg_adr;
  562.             p_Vpc3[dev_num]->dxb_link_status_buf_ptr = p_Vpc3[dev_num]->dxb_link_table_buf_ptr  + (p_Vpc3[dev_num]->len_dxb_link_table_buf >> SEG_MULDIV);
  563.             p_Vpc3[dev_num]->dxb_out_buf_ptr1        = p_Vpc3[dev_num]->dxb_link_status_buf_ptr + (p_Vpc3[dev_num]->len_dxb_link_status_buf >> SEG_MULDIV);
  564.             p_Vpc3[dev_num]->dxb_out_buf_ptr2        = p_Vpc3[dev_num]->dxb_out_buf_ptr1        + (p_Vpc3[dev_num]->len_dxb_out_buf >> SEG_MULDIV);
  565.             p_Vpc3[dev_num]->dxb_out_buf_ptr3        = p_Vpc3[dev_num]->dxb_out_buf_ptr2        + (p_Vpc3[dev_num]->len_dxb_out_buf >> SEG_MULDIV);
  566.         }
  567.     }
  568.     return error;
  569. }
  570. #endif//#ifdef DP_SUBSCRIBER
  573. /*---------------------------------------------------------------------------*/
  574. /*                                                                           */
  575. /*  DP_ERROR_CODE vpc3_calculate_inp_outp_len (UBYTE dev_num,                */
  576. /*                                             VPC3_UNSIGNED8_PTR cfg_ptr,   */
  577. /*                                             UBYTE              cfg_len )  */
  578. /*                                                                           */
  579. /*   function:      Calculation of Inputs/Outputs.                           */
  580. /*                                                                           */
  581. /*   parameter:     cfg_ptr:  Pointer to configuration buffer.               */
  582. /*                  cfg_len:  Length of configuration data.                  */
  583. /*   return value:  -                                                        */
  584. /*                                                                           */
  585. /*---------------------------------------------------------------------------*/
  586. SECTION_DEF_CommuCode DP_ERROR_CODE vpc3_calculate_inp_outp_len (UBYTE dev_num,VPC3_UNSIGNED8_PTR cfg_ptr, UBYTE cfg_len)
  587. {
  588. DP_ERROR_CODE error;
  589. UBYTE         specific_data_length;
  590. UBYTE         temp_outp_data_len;
  591. UBYTE         temp_inp_data_len;
  592. UBYTE         length;
  593. UBYTE         count;
  595.     error = DP_OK;
  596.     temp_outp_data_len = 0;
  597.     temp_inp_data_len  = 0;
  599.     if( (cfg_len > 0)  &&  (cfg_len <= dp_sys[dev_num].cfg_bufsize) )
  600.     {
  601.         for( ; cfg_len > 0; cfg_len -= count)
  602.         {
  603.             count = 0;
  605.             if (*cfg_ptr & VPC3_CFG_IS_BYTE_FORMAT)
  606.             {
  607.                 // general identifier format
  608.                 count++;
  609.                 // cfg_ptr points to "Configurationbyte", CFG_BF means "CFG_IS_BYTE_FORMAT"
  610.                 length = (UBYTE)( (*cfg_ptr & VPC3_CFG_BF_LENGTH) + 1 );
  612.                 if(*cfg_ptr & VPC3_CFG_LENGTH_IS_WORD_FORMAT)
  613.                 {
  614.                     length *= 2;
  615.                 }
  617.                 if(*cfg_ptr & VPC3_CFG_BF_OUTP_EXIST)
  618.                 {
  619.                     temp_outp_data_len += length;
  620.                 }
  622.                 if(*cfg_ptr & VPC3_CFG_BF_INP_EXIST)
  623.                 {
  624.                     temp_inp_data_len += length;
  625.                 }
  627.                 cfg_ptr++;
  628.             }
  629.             else
  630.             {
  631.                 // cfg_ptr points to the headerbyte of "special identifier format
  632.                 // CFG_SF means "CFG_IS_SPECIAL_FORMAT"
  633.                 if(*cfg_ptr & VPC3_CFG_SF_OUTP_EXIST)
  634.                 {
  635.                     count++;    // next UBYTE contains the length of outp_data
  636.                     length = (UBYTE)((*(cfg_ptr + count) & VPC3_CFG_SF_LENGTH) +1);
  638.                     if(*(cfg_ptr + count) & VPC3_CFG_LENGTH_IS_WORD_FORMAT)
  639.                     {
  640.                         temp_outp_data_len += (2*length);
  641.                     }
  642.                     else
  643.                     {
  644.                         temp_outp_data_len += length;
  645.                     }
  646.                 }
  648.                 if(*cfg_ptr & VPC3_CFG_SF_INP_EXIST)
  649.                 {
  650.                     count++;  // next UBYTE copntains the length of inp_data
  651.                     length = (UBYTE)((*(cfg_ptr + count) & VPC3_CFG_SF_LENGTH) +1);
  653.                     if(*(cfg_ptr + count) & VPC3_CFG_LENGTH_IS_WORD_FORMAT)
  654.                     {
  655.                         temp_inp_data_len += (2*length);
  656.                     }
  657.                     else
  658.                     {
  659.                         temp_inp_data_len += length;
  660.                     }
  661.                 }
  663.                 specific_data_length = (UBYTE)(*cfg_ptr & VPC3_CFG_BF_LENGTH);
  665.                 if(specific_data_length != 15)
  666.                 {
  667.                     count = (UBYTE)(count + 1 + specific_data_length);
  668.                     cfg_ptr = cfg_ptr + count;
  669.                 }
  670.                 else
  671.                 {
  672.                     // specific data length = 15 not allowed
  673.                     dp_sys[dev_num].inp_data_len  = 0xFF;
  674.                     dp_sys[dev_num].outp_data_len = 0xFF;
  675.                     error = DP_CALCULATE_IO_ERROR;
  676.                 }
  677.             }
  678.         }//for( ; cfg_len > 0; cfg_len -= count)
  680.         if(  ( cfg_len != 0 ) || ( temp_inp_data_len > dp_sys[dev_num].din_bufsize ) || ( temp_outp_data_len > dp_sys[dev_num].dout_bufsize ) )
  681.         {
  682.             dp_sys[dev_num].inp_data_len  = 0xFF;
  683.             dp_sys[dev_num].outp_data_len = 0xFF;
  685.             error = DP_CALCULATE_IO_ERROR;
  686.         }
  687.         else
  688.         {
  689.             dp_sys[dev_num].inp_data_len  = temp_inp_data_len;
  690.             dp_sys[dev_num].outp_data_len = temp_outp_data_len;
  691.             error = DP_OK;
  692.         }
  693.     }//if( (cfg_len > 0)  &&  (cfg_len <= vpc3_dp_init.cfg_buf_len) )
  694.     else
  695.     {
  696.         dp_sys[dev_num].inp_data_len  = 0xFF;
  697.         dp_sys[dev_num].outp_data_len = 0xFF;
  698.         error = DP_CALCULATE_IO_ERROR;
  699.     }
  701. //TRACE("Dev:%d inp_data_len: %d outp_data_len:%d ", dev_num, dp_sys[dev_num].inp_data_len,dp_sys[dev_num].outp_data_len);
  703.     return error;
  704. }//vpc3_calculate_inp_outp_len (UBYTE dev_num,VPC3_UNSIGNED8_PTR cfg_ptr, UBYTE cfg_len)
  707. /*---------------------------------------------------------------------------*/
  708. /*                                                                           */
  709. /*  DP_ERROR_CODE vpc3_buf_init (UBYTE dev_num)                                       */
  710. /*                                                                           */
  711. /*   function:      Initializing VPC3 buffers.                               */
  712. /*                                                                           */
  713. /*   parameter:     none                                                     */
  714. /*   return value:  DP_OK        : Buffer length OK                          */
  715. /*                  ERROR        : defined in dp_error.h                     */
  716. /*                                                                           */
  717. /*---------------------------------------------------------------------------*/
  718. SECTION_DEF_CommuCode DP_ERROR_CODE vpc3_buf_init(UBYTE dev_num)
  719. {
  720. DP_ERROR_CODE       error;
  721. UWORD               aux_buf_len[2];      // calculated length of AUX buffer
  722. UWORD               r_din_dout_buf_len;  // calculated length of real I/O Data length
  723. UWORD               real_buf_len[3];     // real length of AUX-Buffer
  724. UBYTE               aux_ass;             // Bit array, in which the assignments of AUX1/2 are defined
  726.     error = DP_OK;
  728.     /*-----------------------------------------------------------------------*/
  729.     /* check buffer length                                                   */
  730.     /*-----------------------------------------------------------------------*/
  731.     if (dp_sys[dev_num].dout_bufsize > 244)
  732.     {
  733.         error = DP_DOUT_LEN_ERROR;
  734.     }
  736.     else if(dp_sys[dev_num].din_bufsize > 244)
  737.     {
  738.         error =  DP_DIN_LEN_ERROR;
  739.     }
  741.     else if((dp_sys[dev_num].diag_bufsize < 6) || (dp_sys[dev_num].diag_bufsize > 244))
  742.     {
  743.         error =  DP_DIAG_LEN_ERROR;
  744.     }
  746.     else if((dp_sys[dev_num].prm_bufsize < 7) || (dp_sys[dev_num].prm_bufsize > 244))
  747.     {
  748.         error =  DP_PRM_LEN_ERROR;
  749.     }
  751.     else if((dp_sys[dev_num].cfg_bufsize < 1) || (dp_sys[dev_num].cfg_bufsize > 244))
  752.     {
  753.         error =  DP_CFG_LEN_ERROR;
  754.     }
  756.     else if(dp_sys[dev_num].ssa_bufsize != 0 && ((dp_sys[dev_num].ssa_bufsize < 4) || (dp_sys[dev_num].ssa_bufsize > 244)))
  757.     {
  758.         error = DP_SSA_LEN_ERROR;
  759.     }
  761.     if(error == DP_OK)//else
  762.     {
  763.         /*-------------------------------------------------------------------*/
  764.         /* length of buffers ok, check memory consumption                    */
  765.         /*-------------------------------------------------------------------*/
  766.         if(p_Vpc3[dev_num]->mode_reg0_H & VPC3_SPEC_PRM_BUF_MODE)
  767.         {
  768.             real_buf_len[RBL_PRM] = 0; /* prm-data goes directly into prm-buffer */
  769.         }
  770.         else
  771.         {
  772.             real_buf_len[RBL_PRM] = dp_sys[dev_num].prm_bufsize; // prm-data goes over AUX-buffer
  773.         }
  775.         // length of cfg and ssa buffer
  776.         real_buf_len[RBL_CFG] = dp_sys[dev_num].cfg_bufsize;
  777.         real_buf_len[RBL_SSA] = dp_sys[dev_num].ssa_bufsize;
  779.         /*-------------------------------------------------------------------*/
  780.         /* calculate aux-buffer                                              */
  781.         /*-------------------------------------------------------------------*/
  782.         dp_sys[dev_num].vpc3_used_dp_buf_mem = assign_aux_buf(dev_num,&real_buf_len[0], 3, &aux_ass, &aux_buf_len[0]);
  784.         /*-------------------------------------------------------------------*/
  785.         /* check memory consumption                                          */
  786.         /*-------------------------------------------------------------------*/
  787.         r_din_dout_buf_len = ((dp_sys[dev_num].dout_bufsize + SEG_OFFSET) & SEG_ADDWORD) + ((dp_sys[dev_num].din_bufsize + SEG_OFFSET) & SEG_ADDWORD);
  788.         // DIn DOut buffer
  789.         dp_sys[dev_num].vpc3_used_dp_buf_mem += r_din_dout_buf_len * 3;
  790.         // add Read Config Buffer
  791.         dp_sys[dev_num].vpc3_used_dp_buf_mem += real_buf_len[RBL_CFG];
  792.         // diagnose buffer
  793.         dp_sys[dev_num].vpc3_used_dp_buf_mem += ((dp_sys[dev_num].diag_bufsize + SEG_OFFSET) & SEG_ADDBYTE) * 2;
  794.         // prm buffer
  795.         if(p_Vpc3[dev_num]->mode_reg0_H & VPC3_SPEC_PRM_BUF_MODE)
  796.         {
  797.             // spec. PRM buffer
  798.             real_buf_len[RBL_PRM] = (dp_sys[dev_num].prm_bufsize + SEG_OFFSET) & SEG_ADDBYTE;
  799.             dp_sys[dev_num].vpc3_used_dp_buf_mem += real_buf_len[RBL_PRM];
  800.             p_Vpc3[dev_num]->len_spec_prm_buf = dp_sys[dev_num].prm_bufsize;
  801.         }
  802.         else
  803.         {
  804.             p_Vpc3[dev_num]->len_spec_prm_buf = 0;
  805.         }
  807.         if( dp_sys[dev_num].vpc3_used_dp_buf_mem > sizeof (p_Vpc3[dev_num]->dpbuffer)/BLACKFIN_MULTIPLER  )
  808.         {
  809.             // Error: user needs too much memory
  810.             dp_sys[dev_num].vpc3_used_dp_buf_mem = 0;
  811.             error = DP_LESS_MEM_ERROR;
  812.         }
  813.         else
  814.         {
  815.             /*---------------------------------------------------------------*/
  816.             /* set buffer pointer                                            */
  817.             /*---------------------------------------------------------------*/
  818.             p_Vpc3[dev_num]->aux_buf_sel      = aux_ass;   // AUX-Puffer zuordnen
  820.             p_Vpc3[dev_num]->dout_buf_ptr[0]  = VPC3_DP_BUF_START(dev_num);
  821.             p_Vpc3[dev_num]->dout_buf_ptr[1]  = p_Vpc3[dev_num]->dout_buf_ptr[0]  + (((dp_sys[dev_num].dout_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  822.             p_Vpc3[dev_num]->dout_buf_ptr[2]  = p_Vpc3[dev_num]->dout_buf_ptr[1]  + (((dp_sys[dev_num].dout_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  824.             p_Vpc3[dev_num]->din_buf_ptr[0]   = p_Vpc3[dev_num]->dout_buf_ptr[2]  + (((dp_sys[dev_num].dout_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  825.             p_Vpc3[dev_num]->din_buf_ptr[1]   = p_Vpc3[dev_num]->din_buf_ptr[0]   + (((dp_sys[dev_num].din_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  826.             p_Vpc3[dev_num]->din_buf_ptr[2]   = p_Vpc3[dev_num]->din_buf_ptr[1]   + (((dp_sys[dev_num].din_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  828.             p_Vpc3[dev_num]->diag_buf_ptr[0]  = p_Vpc3[dev_num]->din_buf_ptr[2]   + (((dp_sys[dev_num].din_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  829.             p_Vpc3[dev_num]->diag_buf_ptr[1]  = p_Vpc3[dev_num]->diag_buf_ptr[0]  + (((dp_sys[dev_num].diag_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  831.             p_Vpc3[dev_num]->cfg_buf_ptr      = p_Vpc3[dev_num]->diag_buf_ptr[1]  + (((dp_sys[dev_num].diag_bufsize + SEG_OFFSET) & SEG_ADDBYTE)>>SEG_MULDIV);
  832.             p_Vpc3[dev_num]->read_cfg_buf_ptr = p_Vpc3[dev_num]->cfg_buf_ptr      + (real_buf_len[RBL_CFG]>>SEG_MULDIV);
  834.             p_Vpc3[dev_num]->prm_buf_ptr      = p_Vpc3[dev_num]->read_cfg_buf_ptr + (real_buf_len[RBL_CFG]>>SEG_MULDIV);
  836.             p_Vpc3[dev_num]->aux_buf_ptr[0]   = p_Vpc3[dev_num]->prm_buf_ptr      + (real_buf_len[RBL_PRM]>>SEG_MULDIV);
  837.             if( aux_buf_len[1] != 0 )
  838.             {
  839.                 p_Vpc3[dev_num]->aux_buf_ptr[1]   = p_Vpc3[dev_num]->aux_buf_ptr[0]   + (aux_buf_len[0]>>SEG_MULDIV);
  840.             }
  841.             else
  842.             {
  843.                 p_Vpc3[dev_num]->aux_buf_ptr[1]   = 0;
  844.             }
  846.             if (real_buf_len[RBL_SSA] == 0)
  847.             {
  848.                 // no ssa supported
  849.                 p_Vpc3[dev_num]->ssa_buf_ptr = 0;         /* Dienst sperren */
  850.             }
  851.             else
  852.             {
  853.                 // ssa supported
  854.                 if( aux_buf_len[1] != 0 )
  855.                 {
  856.                     p_Vpc3[dev_num]->ssa_buf_ptr = p_Vpc3[dev_num]->aux_buf_ptr[1] + (aux_buf_len[1]>>SEG_MULDIV);
  857.                 }
  858.                 else
  859.                 {
  860.                     p_Vpc3[dev_num]->ssa_buf_ptr = p_Vpc3[dev_num]->aux_buf_ptr[0] + (aux_buf_len[0]>>SEG_MULDIV);
  861.                 }
  862.             }
  864.             /*---------------------------------------------------------------*/
  865.             /* set buffer length                                             */
  866.             /*---------------------------------------------------------------*/
  867.             p_Vpc3[dev_num]->len_dout_buf    = dp_sys[dev_num].outp_data_len;
  868.             p_Vpc3[dev_num]->len_din_buf     = dp_sys[dev_num].inp_data_len;
  870.             p_Vpc3[dev_num]->len_diag_buf[0] = 6;                // length of Diag Buffers
  871.             p_Vpc3[dev_num]->len_diag_buf[1] = 6;
  873.             if(aux_buf_len[0] >= 244)
  874.             {
  875.                 p_Vpc3[dev_num]->len_ctrl_buf[0] = 244;      // Length AUX1-Buffer
  876.             }
  877.             else
  878.             {
  879.                 p_Vpc3[dev_num]->len_ctrl_buf[0] = aux_buf_len[0];      // Length AUX1-Buffer
  880.             }
  882.             if(aux_buf_len[1] >= 244)
  883.             {
  884.                 p_Vpc3[dev_num]->len_ctrl_buf[1] = 244;      // Length AUX1-Buffer
  885.             }
  886.             else
  887.             {
  888.                 p_Vpc3[dev_num]->len_ctrl_buf[1] = aux_buf_len[1];      // Length AUX1-Buffer
  889.             }
  891.             p_Vpc3[dev_num]->len_cfg_data    = dp_sys[dev_num].cfg_bufsize;
  892.             p_Vpc3[dev_num]->len_prm_data    = dp_sys[dev_num].prm_bufsize;
  893.             p_Vpc3[dev_num]->len_ssa_buf     = dp_sys[dev_num].ssa_bufsize;
  894.         }
  895.     }
  896.     return error;
  897. }//DP_ERROR_CODE vpc3_buf_init(UBYTE dev_num)
  900. /*---------------------------------------------------------------------------*/
  901. /*                                                                           */
  902. /*  UBYTE vpc3_cfg_data_ok(UBYTE dev_num)                                             */
  903. /*                                                                           */
  904. /*  function:      Set Configuration Data ok                                 */
  905. /*                                                                           */
  906. /*  parameter:     none                                                      */
  907. /*  return value:  VPC3_CFG_FINISHED:  The transferred configuration is OK.  */
  908. /*                 VPC3_CFG_CONFLICT:  Repeat verification of the requested  */
  909. /*                                     configuration.                        */
  910. /*                                                                           */
  911. /*---------------------------------------------------------------------------*/
  912. SECTION_DEF_CommuCode UBYTE vpc3_cfg_data_ok(UBYTE dev_num)
  913. {
  914.     return p_Vpc3[dev_num]->ctrl_reg.rd.user_cfg_data_ok;
  915. }
  917. /*---------------------------------------------------------------------------*/
  918. /*                                                                           */
  919. /*  UBYTE vpc3_cfg_data_update(UBYTE dev_num)                                         */
  920. /*                                                                           */
  921. /*  function:      Update Configuration Data                                 */
  922. /*                                                                           */
  923. /*  parameter:     none                                                      */
  924. /*  return value:  VPC3_CFG_FINISHED:  The transferred configuration is OK.  */
  925. /*                 VPC3_CFG_CONFLICT:  Repeat verification of the requested  */
  926. /*                                     configuration.                        */
  927. /*                                                                           */
  928. /*---------------------------------------------------------------------------*/
  929. SECTION_DEF_CommuCode UBYTE vpc3_cfg_data_update(UBYTE dev_num)
  930. {
  931. int nBlackfinLoop;
  932. uint16* pBlackfinAddr;
  933. uint16* pSrcAddr;
  935.     p_Vpc3[dev_num]->len_read_cfg_data = p_Vpc3[dev_num]->len_cfg_data;
  936. //    memcpy( VPC3_GET_READ_CFG_BUF_PTR(dev_num), VPC3_GET_CFG_BUF_PTR(dev_num), p_Vpc3[dev_num]->len_cfg_data);
  937. pSrcAddr = (uint16*)VPC3_GET_CFG_BUF_PTR(dev_num);
  938. pBlackfinAddr = (uint16*)VPC3_GET_READ_CFG_BUF_PTR(dev_num);
  939. for (nBlackfinLoop=0; nBlackfinLoop<BFWORD2BYTE(p_Vpc3[dev_num]->len_cfg_data); nBlackfinLoop++)
  940. {
  941. pBlackfinAddr[nBlackfinLoop] = pSrcAddr[nBlackfinLoop];
  942. }
  944. return p_Vpc3[dev_num]->ctrl_reg.rd.user_cfg_data_ok;
  945. }
  947. /*---------------------------------------------------------------------------*/
  948. /*  D e s c r i p t i o n : vpc3_cfg_data_not_ok                             */
  949. /*                                                                           */
  950. /*   function:      Set Configuration Data not ok                            */
  951. /*                                                                           */
  952. /*   parameter:     none                                                     */
  953. /*   return value:  VPC3_CFG_FINISHED:  The transferred configuration is OK. */
  954. /*                  VPC3_CFG_CONFLICT:  Repeat verification of the requested */
  955. /*                                      configuration.                       */
  956. /*---------------------------------------------------------------------------*/
  957. SECTION_DEF_CommuCode UBYTE vpc3_cfg_data_not_ok(UBYTE dev_num)
  958. {
  959.     return p_Vpc3[dev_num]->ctrl_reg.rd.user_cfg_data_nok;
  960. }
  962. /*---------------------------------------------------------------------------*/
  963. /*  D e s c r i p t i o n : vpc3_get_doutbufptr                              */
  964. /*                                                                           */
  965. /* This function fetches the pointer to the actual output buffer.            */
  966. /*---------------------------------------------------------------------------*/
  967. SECTION_DEF_CommuCode VPC3_UNSIGNED8_PTR vpc3_get_doutbufptr (UBYTE dev_num,UBYTE PTR_ATTR *state_ptr)
  968. {
  969. VPC3_UNSIGNED8_PTR p_doutbuf; // pointer to output buffer ( DP-Master -> VPC3+ )
  971.     *state_ptr = (p_Vpc3[dev_num]->ctrl_reg.rd.next_dout_buf_cmd & (VPC3_NEW_DOUT_BUF | VPC3_DOUT_BUF_CLEARED));
  973.     switch (p_Vpc3[dev_num]->ctrl_reg.rd.dout_buffer_sm & 0x30)    // locate user Dout Buffer
  974.     {
  975.         case 0x10:
  976.         {
  977.             p_doutbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->dout_buf_ptr[0]) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  978.             break;
  979.         }
  981.         case 0x20:
  982.         {
  983.             p_doutbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->dout_buf_ptr[1]) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  984.             break;
  985.         }
  987.         case 0x30:
  988.         {
  989.             p_doutbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->dout_buf_ptr[2]) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  990.             break;
  991.         }
  993.         default:
  994.         {
  995.             p_doutbuf = NULL_PTR;
  996.             break;
  997.         }
  998.     }//switch (p_Vpc3[dev_num]->ctrl_reg.rd.dout_buffer_sm & 0x30)    // locate user Dout Buffer
  1000.     return p_doutbuf;
  1001. }
  1003. /*---------------------------------------------------------------------------*/
  1004. /*  D e s c r i p t i o n : vpc3_get_dinbufptr                               */
  1005. /*                                                                           */
  1006. /* This function fetches the pointer to the actual input buffer.             */
  1007. /*---------------------------------------------------------------------------*/
  1008. SECTION_DEF_CommuCode VPC3_UNSIGNED8_PTR vpc3_get_dinbufptr (UBYTE dev_num)
  1009. {
  1010. VPC3_UNSIGNED8_PTR p_dinbuf; // pointer to output buffer ( VPC3 -> DP-Master )
  1012.     switch (p_Vpc3[dev_num]->ctrl_reg.rd.din_buffer_sm & 0x30)         // locate user Din Buffer
  1013.     {
  1014.         case 0x10:
  1015.         {
  1016.             p_dinbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->din_buf_ptr[0]) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1017.             break;
  1018.         }
  1020.         case 0x20:
  1021.         {
  1022.             p_dinbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->din_buf_ptr[1]) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1023.             break;
  1024.         }
  1026.         case 0x30:
  1027.         {
  1028.             p_dinbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->din_buf_ptr[2]) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1029.             break;
  1030.         }
  1032.         default:
  1033.         {
  1034.             p_dinbuf = NULL_PTR;
  1035.             break;
  1036.         }
  1037.     }//switch (p_Vpc3[dev_num]->ctrl_reg.rd.din_buffer_sm & 0x30)
  1039.     return p_dinbuf;
  1040. }
  1042. /*---------------------------------------------------------------------------*/
  1043. /*  D e s c r i p t i o n : vpc3_get_dxb_outbufptr                           */
  1044. /*                                                                           */
  1045. /* This function fetches the pointer to the actual dxb output buffer.        */
  1046. /*---------------------------------------------------------------------------*/
  1047. #ifdef DP_SUBSCRIBER
  1048. SECTION_DEF_CommuCode VPC3_UNSIGNED8_PTR vpc3_get_dxb_outbufptr (UBYTE dev_num,UBYTE PTR_ATTR *state_ptr)
  1049. {
  1050. VPC3_UNSIGNED8_PTR p_doutbuf; // pointer to output buffer (DP-Master -> VPC3+ )
  1052.     *state_ptr = (p_Vpc3[dev_num]->ctrl_reg.rd.next_dxb_buf_cmd & (VPC3_NEW_DOUT_BUF | VPC3_DOUT_BUF_CLEARED));
  1054.     switch (p_Vpc3[dev_num]->ctrl_reg.rd.dxbout_buffer_sm & 0x30)    // locate user DXBout Buffer
  1055.     {
  1056.         case 0x10:
  1057.         {
  1058.             p_doutbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->dxb_out_buf_ptr1) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1059.             break;
  1060.         }
  1062.         case 0x20:
  1063.         {
  1064.             p_doutbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->dxb_out_buf_ptr2) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1065.             break;
  1066.         }
  1068.         case 0x30:
  1069.         {
  1070.             p_doutbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->dxb_out_buf_ptr3) << BLACKFIN_SEG_MULDIV)+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1071.             break;
  1072.         }
  1074.         default:
  1075.         {
  1076.             p_doutbuf = NULL_PTR;
  1077.             break;
  1078.         }
  1079.     }//switch (p_Vpc3[dev_num]->ctrl_reg.rd.dxb_out_buffer_sm & 0x30)    // locate user Dout Buffer
  1081.     return p_doutbuf;
  1082. }
  1084. /*-------------------------------------------------------------------*/
  1085. /* function: dxb_subscriber_table_to_dxb_link_table                  */
  1086. /*-------------------------------------------------------------------*/
  1087. SECTION_DEF_CommuCode void dxb_subscriber_table_to_dxb_link_table(UBYTE dev_num, PRM_SUBSCRIBER_TABLE_PTR dxb_ptr, UBYTE NrOfLinks )
  1088. {
  1089. PRM_DXB_LINK_TABLE  link_table;
  1090. UBYTE               i;
  1091. int nBlackfinLoop;
  1092. uint16* pBlackfinAddr;
  1093. uint16* pSrcAddr;
  1095.     memset( &link_table, 0, sizeof(PRM_DXB_LINK_TABLE));//!!! 如果V2要改...
  1097.     link_table.version = dxb_ptr->version;
  1099.     for(i = 0; i < NrOfLinks; i++ )
  1100.     {
  1101.         link_table.link_table_entry[i].publisher_addr   = dxb_ptr->subscriber_table_entry[i].publisher_addr;
  1102.         link_table.link_table_entry[i].publisher_length = dxb_ptr->subscriber_table_entry[i].publisher_length;
  1103.         link_table.link_table_entry[i].sample_offset    = dxb_ptr->subscriber_table_entry[i].sample_offset;
  1104.         link_table.link_table_entry[i].sample_length    = dxb_ptr->subscriber_table_entry[i].sample_length;
  1105.     }
  1107.     VPC3_SET_DXB_LINK_TABLE_LEN(dev_num, NrOfLinks<<2);
  1108.     //memcpy( VPC3_GET_DXB_LINK_TABLE_BUF_PTR(dev_num), &link_table.link_table_entry[0].publisher_addr, (NrOfLinks<<2));
  1109. pBlackfinAddr = (uint16*)VPC3_GET_DXB_LINK_TABLE_BUF_PTR(dev_num);
  1110. pSrcAddr = (uint16*)&link_table.link_table_entry[0].publisher_addr;
  1111. for (nBlackfinLoop=0; nBlackfinLoop<(NrOfLinks<<2); nBlackfinLoop++)
  1112. {
  1113. pBlackfinAddr[nBlackfinLoop] = pSrcAddr[nBlackfinLoop];
  1114. }
  1116. }
  1118. /*-------------------------------------------------------------------*/
  1119. /* function: check_dxb_link_table                                    */
  1120. /*-------------------------------------------------------------------*/
  1121. SECTION_DEF_CommuCode UBYTE check_dxb_link_table(UBYTE dev_num)
  1122. {
  1123. VPC3_DXB_LINK_TABLE_PTR dxb_ptr;
  1124. UBYTE                   ret_value;
  1125. UBYTE                   i;
  1127.     ret_value = DP_OK;
  1128.     dxb_ptr = (VPC3_DXB_LINK_TABLE_PTR)VPC3_GET_DXB_LINK_TABLE_BUF_PTR(dev_num);
  1130.     for(i = 0; i < (VPC3_GET_DXB_LINK_TABLE_LEN(dev_num)/4); i++)
  1131.     {
  1132.         if(    (dxb_ptr->link_table_entry[i].publisher_addr   > 125)
  1133.             || (dxb_ptr->link_table_entry[i].publisher_length < 1  )
  1134.             || (dxb_ptr->link_table_entry[i].publisher_length > 244)
  1135.             || (dxb_ptr->link_table_entry[i].sample_offset    > (dxb_ptr->link_table_entry[i].publisher_length - 1))
  1136.             || ((dxb_ptr->link_table_entry[i].sample_offset + dxb_ptr->link_table_entry[i].sample_length) >
  1137.                                                                         (dxb_ptr->link_table_entry[i].publisher_length))
  1138.             || (dxb_ptr->link_table_entry[i].sample_length > MAX_DATA_PER_LINK-2)
  1139.           )
  1140.         {
  1141.             ret_value = DP_PRM_DXB_ERROR;
  1142.             VPC3_SET_DXB_LINK_TABLE_LEN(dev_num,0);
  1143.             break;
  1144.         }
  1145.     }
  1147.     return ret_value;
  1148. }
  1150. /*-------------------------------------------------------------------*/
  1151. /* function: build_dxb_link_status                                   */
  1152. /*-------------------------------------------------------------------*/
  1153. SECTION_DEF_CommuCode void build_dxb_link_status(UBYTE dev_num)
  1154. {
  1155. VPC3_DXB_LINK_TABLE_PTR dxb_ptr;
  1156. VPC3_DXB_LINK_STATUS    link_status;
  1157. UBYTE                   i;
  1158. int nBlackfinLoop;
  1159.        uint16* pBlackfinAddr;
  1160.        uint16* pSrcAddr;
  1162.     memset( &link_status, 0, sizeof(VPC3_DXB_LINK_STATUS));//!!! 如果V2要改...
  1164.     dxb_ptr = (VPC3_DXB_LINK_TABLE_PTR)VPC3_GET_DXB_LINK_TABLE_BUF_PTR(dev_num);
  1166.     link_status.header           = 4+(VPC3_GET_DXB_LINK_TABLE_LEN(dev_num)/2);
  1167.     link_status.status_type      = 0x83;
  1168.     link_status.slot_number      = 0x00;
  1169.     link_status.status_specifier = 0x00;
  1171.     for(i = 0; i < ((link_status.header-4) / 2); i++)
  1172.     {
  1173.         link_status.link_status[i].publisher_addr = dxb_ptr->link_table_entry[i].publisher_addr;
  1174.         link_status.link_status[i].link_status    = 0x00;
  1175.     }
  1177.     VPC3_SET_DXB_LINK_STATUS_LEN(dev_num, link_status.header);
  1178.     //memcpy( VPC3_GET_DXB_LINK_STATUS_BUF_PTR(dev_num), &link_status, link_status.header);
  1179. pBlackfinAddr = (uint16*)VPC3_GET_DXB_LINK_STATUS_BUF_PTR(dev_num);
  1180. pSrcAddr = (uint16*)&link_status;
  1182. for (nBlackfinLoop=0; nBlackfinLoop<link_status.header; nBlackfinLoop++)
  1183. {
  1184. pBlackfinAddr[nBlackfinLoop] = pSrcAddr[nBlackfinLoop];
  1185. }
  1187. }
  1189. #endif//#ifdef DP_SUBSCRIBER
  1191. /*---------------------------------------------------------------------------*/
  1192. /*                                                                           */
  1193. /*  The function provides the actual prm-master by read out the diag-        */
  1194. /*  buffer in vpc3.                                                          */
  1195. /*---------------------------------------------------------------------------*/
  1196. SECTION_DEF_CommuCode UBYTE vpc3_get_master(UBYTE dev_num)
  1197. {
  1198. UBYTE  master;
  1200.     master = *((VPC3_UNSIGNED8_PTR)(((VPC3_ADR)(( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[0]) << SEG_MULDIV)+3)*BLACKFIN_MULTIPLER+((VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num)))));
  1202.     if( (master&0xff) == 0xFF )//2009.11.7
  1203.     {
  1204.         master = *((VPC3_UNSIGNED8_PTR)(((VPC3_ADR)(( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[1]) << SEG_MULDIV)+3)*BLACKFIN_MULTIPLER+((VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num)))));
  1205.     }
  1206.     return (master&0xff);//2009.11.7
  1207. }
  1209. /********************************************************************************
  1210. *                                                                               *
  1211. *  UWORD assign_aux_buf (UBYTE dev_num,   UWORD PTR_ATTR *lens, UBYTE count,                  *
  1212. *                           UBYTE PTR_ATTR *assign,                             *
  1213. *                           UWORD PTR_ATTR *aux_len)                            *
  1214. *                                                                              *
  1215. *   function:      Calculate length of AUX buffers.                            *
  1216. *                                                                              *
  1217. *   parameter:     lens    : pointer of list to the buffer length              *
  1218. *                  count   : length of list (2..3)                             *
  1219. *                  assign  : Bit array, in which the assignments of the        *
  1220. *                            AUX-buffers1 and 2 are defined to the control     *
  1221. *                            buffers, SSA-Buf, PRM-Buf, Cfg-Buf                *
  1222. *                  aux_len : Pointer to a 2 byte field of aux-buffer length.   *
  1223. *   return value:  count of bytes used for aux buffers.                        *
  1224. *                                                                              *
  1225. ********************************************************************************/
  1226. SECTION_DEF_CommuCode UWORD assign_aux_buf(UBYTE dev_num,UWORD PTR_ATTR *lens, UBYTE count, UBYTE PTR_ATTR *assign, UWORD PTR_ATTR *aux_len)
  1227. {
  1228. UWORD   min_len = 0xffff;     // calculated minimal length
  1229. UBYTE   min_step = 0;         // step by calculated minimal length
  1230. UBYTE   i,j;
  1231. UBYTE   pos[3];               // memory for position of length
  1232. UWORD   lensx[3];             // workarea for calculated length
  1233. UBYTE   step;                 // counter
  1234. UWORD   wtmp;                 // tmp-variable for calculated length
  1235. UBYTE   tmp;                  // tmp-variable for calculated length
  1236.                               // tmp-varaiable for sorted positions
  1238.     // check count
  1239.     if((count == 2) || (count == 3))
  1240.     {
  1241.         for(i = 0; i < count; i++)
  1242.         {
  1243.             // init memory for position of length
  1244.             pos[i] = i;
  1245.             // copy length into workarea for calculated length
  1246.             lensx[i] = lens[i];
  1247.             // put length to 8 Bit Segmentaddresses
  1248.             lensx[i] = (lensx[i] + SEG_OFFSET) & SEG_ADDWORD;
  1249.         }
  1251.         // sort length, highest length to index 0
  1252.         for(i = 0; i < count-1; i++)
  1253.         {
  1254.             for(j = i+1; j < count; j++)
  1255.             {
  1256.                 if(lensx[i] < lensx[j])
  1257.                 {
  1258.                     // found higher length
  1259.                     tmp = lensx[i];          // swap length
  1260.                     lensx[i] = lensx[j];
  1261.                     lensx[j] = tmp;
  1262.                     tmp = pos[i];            // swap position
  1263.                     pos[i] = pos[j];
  1264.                     pos[j] = tmp;
  1265.                 }
  1266.             }
  1267.         }
  1269.         // delete zero length from list lensx
  1270.         for(i = count; i > 0; i--)
  1271.         {
  1272.             if(lensx[i-1] == 0)
  1273.             {
  1274.                 count--;
  1275.             }
  1276.         }
  1278.         if( count == 0 )
  1279.         {
  1280.             min_len = 0;     // Error: no defined buffer length
  1281.         }
  1283.         // gradual length assign to aux-buffer
  1284.         for(step = 0; step < count; step++)
  1285.         {
  1286.             // get length for AUX-Buffer 1
  1287.             aux_len[0] = 0;
  1289.             for(i = step; i < count; i++)
  1290.             {
  1291.                 if(aux_len[0] < lensx[i])
  1292.                 {
  1293.                     aux_len[0] = lensx[i];
  1294.                 }
  1295.             }
  1297.             aux_len[0] = aux_len[0] * (count - step + 1);
  1299.             // get length for AUX-Buffer 2
  1300.             aux_len[1] = 0;
  1302.             for(i = 0; i < step; i++)
  1303.             {
  1304.                 if(aux_len[1] < lensx[i])
  1305.                 {
  1306.                     aux_len[1] = lensx[i];
  1307.                 }
  1308.             }
  1310.             aux_len[1] = aux_len[1] * (step + 1);
  1312.             if((aux_len[0] + aux_len[1]) < min_len)
  1313.             {
  1314.                 // new minimal length found
  1315.                 min_len = aux_len[0] + aux_len[1];
  1316.                 min_step = step;
  1317.             }
  1318.         }
  1320.         // calculate length for AUX Buffer 1
  1321.         aux_len[0] = 0;
  1323.         for(i = min_step; i < count; i++)
  1324.         {
  1325.             if(aux_len[0] < lensx[i])
  1326.             {
  1327.                 aux_len[0] = lensx[i];
  1328.             }
  1329.         }
  1331.         // put length, assigned for AUX buffer 1
  1332.         for(i = min_step; i < count; i++)
  1333.         {
  1334.             lens[pos[i]] = aux_len[0];
  1335.         }
  1337.         // calculate length of AUX-Buffer 2
  1338.         aux_len[1] = 0;
  1340.         for(i = 0; i < min_step; i++)
  1341.         {
  1342.             if (aux_len[1] < lensx[i])
  1343.             {
  1344.                 aux_len[1] = lensx[i];
  1345.             }
  1346.         }
  1348.         *assign = 0;    // put all buffer to AUX-Buffer 1
  1350.         for(i = 0; i < min_step; i++)
  1351.         {
  1352.             lens[pos[i]] = aux_len[1];
  1353.             *assign |= 0x1 << pos[i];
  1354.         }
  1356.         //check here for VPC3+/B
  1357.         //handle Cfg-telegram only over AUX-Buffer 1
  1358.         if( *assign & 0x02 )
  1359.         {
  1360.             tmp = (*assign);
  1361.             *assign = ((~tmp)&0x07);
  1362.             //*assign &= 0x07;
  1363.             wtmp = aux_len[0];
  1364.             aux_len[0] = aux_len[1];
  1365.             aux_len[1] = wtmp;
  1366.         }
  1368.     }
  1369.     else
  1370.     {
  1371.         min_len = 0; // error
  1372.     }
  1374.     return min_len;
  1375. }
  1377. /*---------------------------------------------------------------------------*/
  1378. /*  void vpc3_set_io_data_len(UBYTE dev_num)                                          */
  1379. /*---------------------------------------------------------------------------*/
  1380. SECTION_DEF_CommuCode void vpc3_set_io_data_len(UBYTE dev_num)
  1381. {
  1382.     // length of buffers OK, set real buffers
  1383.     p_Vpc3[dev_num]->len_dout_buf = dp_sys[dev_num].outp_data_len;
  1384.     p_Vpc3[dev_num]->len_din_buf  = dp_sys[dev_num].inp_data_len;
  1385. }
  1388. /*---------------------------------------------------------------------------*/
  1389. /*  D e s c r i p t i o n : vpc3_get_diagbufptr                              */
  1390. /*                                                                           */
  1391. /* This function fetches the pointer to the actual diagnosis buffer.         */
  1392. /*---------------------------------------------------------------------------*/
  1393. SECTION_DEF_CommuCode VPC3_UNSIGNED8_PTR vpc3_get_diagbufptr (UBYTE dev_num)
  1394. {
  1395. VPC3_UNSIGNED8_PTR p_diagbuf; // pointer to diagnosis buffer
  1397.     if((p_Vpc3[dev_num]->ctrl_reg.rd.diag_buffer_sm & 0x03) == 0x01)           // locate Diag Buffer
  1398.     {
  1399.         p_diagbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)(( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[0]) << BLACKFIN_SEG_MULDIV))+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1400.     }
  1401.     else
  1402.     {
  1403.         if((p_Vpc3[dev_num]->ctrl_reg.rd.diag_buffer_sm & 0x0C) == 0x04)
  1404.         {
  1405.             p_diagbuf = (VPC3_UNSIGNED8_PTR)((VPC3_ADR)(( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[1]) << BLACKFIN_SEG_MULDIV))+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));
  1406.         }
  1407.         else
  1408.         {
  1409.             p_diagbuf = NULL_PTR;
  1410.         }
  1411.     }
  1412.     return p_diagbuf;
  1413. }
  1415. /*---------------------------------------------------------------------------*/
  1416. /* function: vpc3_set_diag_update_all                                        */
  1417. /*---------------------------------------------------------------------------*/
  1418. SECTION_DEF_CommuCode VPC3_UNSIGNED8_PTR vpc3_set_diag_update_all(UBYTE dev_num, UBYTE diag_state, UBYTE diag_len )
  1419. {
  1420. VPC3_UNSIGNED8_PTR p_diagbuf; // pointer to diagnosis buffer
  1422.     if((p_Vpc3[dev_num]->ctrl_reg.rd.diag_buffer_sm & 0x03) == 0x01)           // locate Diag Buffer
  1423.     {
  1424.         p_Vpc3[dev_num]->len_diag_buf[0] = diag_len; // length of Diag Buffer 1
  1425.         *((VPC3_UNSIGNED8_PTR)(((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[0]) << BLACKFIN_SEG_MULDIV)+((VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num))))) = diag_state;
  1426.     }
  1427.     else
  1428.     {
  1429.         if((p_Vpc3[dev_num]->ctrl_reg.rd.diag_buffer_sm & 0x0C) == 0x04)
  1430.         {
  1431.             p_Vpc3[dev_num]->len_diag_buf[1] = diag_len;  // length of Diag Buffer 2
  1432.             *((VPC3_UNSIGNED8_PTR)(((VPC3_ADR)( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[1]) << BLACKFIN_SEG_MULDIV)+((VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num))))) = diag_state;
  1433.         }
  1434.     }
  1436.     switch( p_Vpc3[dev_num]->ctrl_reg.rd.new_diag_buf_cmd & 0x03 )
  1437.     {
  1438.         case 1:   // use buffer 1
  1439.         {
  1440.             p_diagbuf = (VPC3_UNSIGNED8_PTR)(((VPC3_ADR)(( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[0]) << BLACKFIN_SEG_MULDIV))+((VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num))));
  1441.             break;
  1442.         }
  1444.         case 2:   // use buffer 2
  1445.         {
  1446.             p_diagbuf = (VPC3_UNSIGNED8_PTR)(((VPC3_ADR)(( BFWORD2BYTE(p_Vpc3[dev_num]->diag_buf_ptr[1]) << BLACKFIN_SEG_MULDIV))+((VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num))));
  1447.             break;
  1448.         }
  1450.         default:
  1451.         {
  1452.             // no buffer available
  1453.             p_diagbuf = NULL_PTR;
  1454.             break;
  1455.         }
  1456.     }
  1458.     return p_diagbuf;
  1459. }
  1461. /*---------------------------------------------------------------------------*/
  1462. /* function: reset_diagnostic_buffer                                         */
  1463. /*---------------------------------------------------------------------------*/
  1464. SECTION_DEF_CommuCode void reset_diagnostic_buffer(UBYTE dev_num)
  1465. {
  1466. VPC3_UNSIGNED8_PTR  diag_ptr;
  1468.     do
  1469.     {
  1470.         //fetch new diagnosis buffer
  1471.         diag_ptr = vpc3_get_diagbufptr(dev_num);
  1472.     }
  1473.     while(diag_ptr == NULL_PTR );
  1475.     //clear diagnostic buffer
  1476.     vpc3_set_diag_update_all(dev_num, 0, 6 );
  1477. }//void reset_diagnostic_buffer(UBYTE dev_num)
  1479. /*--------------------------------------------------------------------------*/
  1480. /* set_diagnose (called by DP, DPV1-ALARM)                                 */
  1481. /*--------------------------------------------------------------------------*/
  1482. SECTION_DEF_CommuCode DP_ERROR_CODE set_diagnosis(UBYTE dev_num, VPC3_UNION_DIAG_PTR user_diag, UBYTE user_diag_len, UBYTE diag_control, UBYTE check_diag_flag )
  1483. {
  1484. VPC3_UNION_DIAG_PTR tmp_user_diag;
  1485. DP_ERROR_CODE       ret_value;
  1486. UBYTE               tmp_user_diag_len;
  1487. UBYTE               tmp_len;
  1488. UBYTE               dp_state;
  1489. int nBlackfinLoop;
  1490. uint16* pBlackfinAddr;
  1491. //uint16* pSrcAddr;
  1492. ret_value = DP_OK;
  1494.     //check available diag buffer
  1495.     if( dp_sys[dev_num].diag_buf_ptr.byte_ptr != NULL_PTR )
  1496.     {
  1497.         tmp_user_diag     = user_diag;
  1498.         tmp_user_diag_len = user_diag_len;
  1500.         dp_state = VPC3_GET_DP_STATE(dev_num);
  1501.         if( (dp_state == DATA_EX) && (check_diag_flag == TRUE) )
  1502.         {
  1503.             if( VPC3_GET_DIAG_FLAG(dev_num) )
  1504.             {
  1505.                 //old diagnosis not send
  1506.                 ret_value = DP_DIAG_OLD_DIAG_NOT_SEND_ERROR;
  1507.             }//if( VPC3_GET_DIAG_FLAG(dev_num) )
  1508.         }//if( (dp_state == DATA_EX) && (check_diag_flag == TRUE) )
  1510.         // check user_diag_len
  1511.         if( user_diag_len > (dp_sys[dev_num].diag_bufsize-6) )
  1512.         {
  1513.             ret_value = DP_DIAG_BUFFER_LENGTH_ERROR;
  1514.         }//if( user_diag_len > (dp_sys[dev_num].diag_bufsize-6) )
  1516.         if( ret_value == DP_OK )
  1517.         {
  1518.             //check control byte
  1519.             switch(diag_control )
  1520.             {
  1521.                 case EXT_DIAG_SET:
  1522.                 {
  1523.                     if( user_diag_len == 0 )
  1524.                     {
  1525.                         ret_value = DP_DIAG_CONTROL_BYTE_ERROR;
  1526.                     }//if( user_diag_len == 0 )
  1527.                     break;
  1528.                 }//case EXT_DIAG_SET:
  1530.                 default:
  1531.                 {
  1532.                     //do nothing
  1533.                     break;
  1534.                 }//default:
  1535.             }//switch( diag_control )
  1537.             //check user diag buffer contents
  1538.             while((0 < tmp_user_diag_len) && (DP_OK == ret_value) )
  1539.             {
  1540.                 tmp_len = tmp_user_diag.struc_ptr->dev.sign_len;
  1541.                 switch(DIAG_TYPE_MASK & tmp_user_diag.struc_ptr->dev.sign_len )
  1542.                 {
  1543.                     case DIAG_TYPE_DEV:
  1544.                     {
  1545.                         if( STATUS_DIAG_HEAD_SIZE > (tmp_len = (~DIAG_TYPE_MASK) & tmp_len) )
  1546.                         {
  1547.                             ret_value = DP_DIAG_BUFFER_ERROR;
  1548.                         }//if( STATUS_DIAG_HEAD_SIZE > (tmp_len = (~DIAG_TYPE_MASK) & tmp_len) )
  1549.                         break;
  1550.                     }//case DIAG_TYPE_DEV:
  1552.                     case DIAG_TYPE_KEN:
  1553.                     {
  1554.                         if ( 0 == (tmp_len = (~DIAG_TYPE_MASK) & tmp_len) )
  1555.                         {
  1556.                             ret_value = DP_DIAG_BUFFER_ERROR;
  1557.                         }//if ( 0 == (tmp_len = (~DIAG_TYPE_MASK) & tmp_len) )
  1558.                         break;
  1559.                     }//case DIAG_TYPE_KEN:
  1561.                     case DIAG_TYPE_CHN:
  1562.                     {
  1563.                         tmp_len = DIAG_TYPE_CHN_SIZE;
  1564.                         break;
  1565.                     }//case DIAG_TYPE_CHN:
  1567.                     case DIAG_TYPE_REV:
  1568.                     {
  1569.                         tmp_len = DIAG_TYPE_REV_SIZE;
  1570.                         if( dp_state != DATA_EX )
  1571.                         {
  1572.                             // only allowed in state DATA_EX
  1573.                             ret_value = DP_DIAG_SEQUENCE_ERROR;
  1574.                         }//if( dp_state != DATA_EX )
  1575.                         break;
  1576.                     }//case DIAG_TYPE_REV:
  1578.                     default:
  1579.                     {
  1580.                         //not possible!
  1581.                         ret_value = DP_DIAG_NOT_POSSIBLE_ERROR;
  1582.                         break;
  1583.                     }//default:
  1584.                 }//switch(DIAG_TYPE_MASK & tmp_user_diag.struc_ptr->dev.sign_len )
  1586.                 tmp_user_diag_len      -= tmp_len;
  1587.                 tmp_user_diag.byte_ptr += tmp_len;
  1589.             }//while( (0 < tmp_user_diag_len) && (DP_OK == ret_value) )
  1591.             if( ret_value == DP_OK )
  1592.             {
  1593.                 //copy to diagnosis buffer
  1594.                 //memcpy( dp_sys[dev_num].diag_buf_ptr.byte_ptr+DIAG_NORM_DIAG_SIZE, user_diag.byte_ptr, user_diag_len );
  1595. pBlackfinAddr = (uint16*)dp_sys[dev_num].diag_buf_ptr.byte_ptr;
  1596. pBlackfinAddr = pBlackfinAddr + DIAG_NORM_DIAG_SIZE;
  1597. for (nBlackfinLoop=0; nBlackfinLoop<user_diag_len; nBlackfinLoop++)
  1598. {
  1599. pBlackfinAddr[nBlackfinLoop] = user_diag.byte_ptr[nBlackfinLoop];
  1600. }
  1602.                 dp_sys[dev_num].diag_buf_ptr.byte_ptr = vpc3_set_diag_update_all(dev_num, diag_control, (DIAG_NORM_DIAG_SIZE + user_diag_len) );
  1603.             }//if( ret_value == DP_OK )
  1604.         }//if( ret_value == DP_OK )
  1605.     }//if( dp_sys[dev_num].diag_buf_ptr.byte_ptr != NULL_PTR )
  1606.     else
  1607.     {
  1608. // TRACE("set_diagnosis no diagnosis buffer...");
  1610.         //Fetch new diagnosis buffer
  1611.         dp_sys[dev_num].diag_buf_ptr.byte_ptr = vpc3_get_diagbufptr(dev_num);
  1612.         //wait for next free diag_buffer
  1613.         ret_value = DP_DIAG_NO_BUFFER_ERROR;
  1614.     }//else of if( dp_sys[dev_num].diag_buf_ptr.byte_ptr != NULL_PTR )
  1615.     return ret_value;
  1616. }//DP_ERROR_CODE set_diagnosis(UBYTE dev_num, VPC3_UNION_DIAG_PTR user_diag, UBYTE user_diag_len, UBYTE diag_control, UBYTE check_diag_flag )
  1618. /*-------------------------------------------------------------------*/
  1619. /* function: vpc3_get_free_memory                                    */
  1620. /*-------------------------------------------------------------------*/
  1621. SECTION_DEF_CommuCode VPC3_UNSIGNED8_PTR vpc3_get_free_memory(UBYTE dev_num, UWORD PTR_ATTR *mem_len )
  1622. {
  1623.     //return the address and the number of bytes of unused SPC3-ram
  1624.     if( dp_sys[dev_num].vpc3_used_dp_buf_mem < ASIC_USER_RAM )
  1625.     {
  1626.         *mem_len = ASIC_USER_RAM - dp_sys[dev_num].vpc3_used_dp_buf_mem;
  1628.         return (VPC3_UNSIGNED8_PTR)((VPC3_ADR)(dp_sys[dev_num].vpc3_used_dp_buf_mem + SAP_LENGTH + DP_ORG_LENGTH)*BLACKFIN_MULTIPLER+(VPC3_ADR)VPC3_ASIC_ADDRESS(dev_num));;
  1629.     }
  1630.     else
  1631.     {
  1632.         *mem_len = 0;
  1633.         return NULL_PTR;
  1634.     }
  1635. }//VPC3_UNSIGNED8_PTR vpc3_get_free_memory(UBYTE dev_num, UWORD PTR_ATTR *mem_len )
  1637. /*-------------------------------------------------------------------*/
  1638. /* function: set_alarm                                               */
  1639. /*-------------------------------------------------------------------*/
  1640. SECTION_DEF_CommuCode UBYTE set_alarm(UBYTE dev_num, ALARM_STATUS_PDU_PTR user_alarm_ptr, UBYTE callback  )
  1641. {
  1642.     #ifdef DP_ALARM
  1643.         return set_alarm__(dev_num, user_alarm_ptr, callback );
  1644.     #else
  1645.         user_alarm_ptr = user_alarm_ptr;    //avoid warning
  1646.         callback       = callback;          //avoid warning
  1647.         return SET_ALARM_AL_STATE_CLOSED;
  1648.     #endif
  1649. }//UBYTE set_alarm(UBYTE dev_num, ALARM_STATUS_PDU_PTR user_alarm_ptr, UBYTE callback  )
  1651. /*-------------------------------------------------------------------*/
  1652. /* function: dpv1 statemachines                                      */
  1653. /*-------------------------------------------------------------------*/
  1654. SECTION_DEF_CommuCode void vpc3_dpv1_statemachine(UBYTE dev_num)
  1655. {
  1656.     #ifdef DP_MSAC_C1
  1657.         msac_c1_process(dev_num);    // state machine MSAC_C1
  1658.     #endif
  1660.     #ifdef DP_ALARM
  1661.         alarm_process(dev_num);      // state machine ALARM
  1662.     #endif
  1664.     #ifdef DP_MSAC_C2
  1665.         msac_c2_process(dev_num);    // state machine MSAC_C2
  1666.     #endif
  1668.     #ifdef DP_FDL
  1669.         fdl_cyclic_service(dev_num); // state machine FDL
  1670.     #endif
  1671. }//void vpc3_dpv1_statemachine(UBYTE dev_num)
  1673. /*****************************************************************************/
  1674. /*  Copyright (C) profichip GmbH 2004. Confidential.                         */
  1675. /*****************************************************************************/