distrib/sources/avt/avt_init_funcs.c

   1 #include <stdlib.h>
   2 #include "avt_lib.h"
   3
   4
   5 char *ANNOT_T_D=NULL, *ANNOT_T_S=NULL, *ANNOT_T_G=NULL, *ANNOT_T_B=NULL;
   6 char *ANNOT_R_POS=NULL, *ANNOT_R_NEG=NULL;
   7 char *ANNOT_D_POS=NULL, *ANNOT_D_NEG=NULL;
   8 char *ANNOT_C_POS=NULL, *ANNOT_C_NEG=NULL;
   9 unsigned long int RCN_CACHE_SIZE=10*1024*1024;
  10
  11 int avtAnnotationDeviceConnectorSetting_init(char *var, char *val, char *result)
  12 {
  13   char **items[]={&ANNOT_T_S, &ANNOT_T_G, &ANNOT_T_D, &ANNOT_T_B,
  14                   &ANNOT_R_POS, &ANNOT_R_NEG,
  15                   &ANNOT_C_POS, &ANNOT_C_NEG,
  16                   &ANNOT_D_POS, &ANNOT_D_NEG};
  17   char buf[1024];
  18   char *c, *tok;
  19   unsigned int i=0;
  20
  21   strcpy(buf, val);
  22   tok=strtok_r(buf, " ", &c);
  23   while (tok!=NULL && i<sizeof(items)/sizeof(*items))
  24     {
  25       if (*items[i]!=NULL) free(*items[i]);
  26       if (strcmp(tok,"-")!=0) *items[i]=strdup(tok);
  27       tok=strtok_r(NULL, " ", &c);
  28       i++;
  29     }
  30
  31   if (i!=sizeof(items)/sizeof(*items))
  32   {
  33     avt_errmsg(AVT_ERRMSG, "041", AVT_ERROR, val, var);
  34     return 0;
  35   }
  36
  37   return 1;
  38 }
  39
  40 // -----------------------------------------
  41 char env_SIMUINV=' ';
  42 char *SIMUINVCONENAME=NULL, *SIMUINV_PREFIX=NULL;
  43 int tpiv_inverter_config_reverse=1;
  44 float tpiv_inverter_config_t0r=0, tpiv_inverter_config_t0f=0;
  45 float tpiv_inverter_config_tmax=100e-12;
  46
  47 int tasSimulateInverter_init(char *var, char *env, char *result)
  48 {
  49   char *tmp;
  50   if (SIMUINV_PREFIX!=NULL) free(SIMUINV_PREFIX);
  51   if (SIMUINVCONENAME!=NULL) free(SIMUINVCONENAME);
  52
  53   SIMUINV_PREFIX=NULL;
  54
  55   if (!env)
  56   {
  57     env_SIMUINV = ' ';
  58   }
  59   else {
  60     if (*env == 'S')
  61       env_SIMUINV = 'S';
  62     else
  63       env_SIMUINV = 'T';
  64     env++;
  65     while (*env == ' ' && *env != '\0')
  66       env++;
  67     tmp=env;
  68     while (*env != ' ' && *env != '\0')
  69       env++;
  70     if (*env==' ') *env='\0', env++;
  71     if (*tmp != '\0')
  72       SIMUINVCONENAME = strdup(tmp);
  73     while (*env == ' ' && *env != '\0')
  74       env++;
  75     tmp=env;
  76     if (*tmp!='\0') SIMUINV_PREFIX = strdup(tmp);
  77
  78
  79     printf
  80         ("*** inverter simulator for cone %s with model '%c' ***\n",
  81          SIMUINVCONENAME, env_SIMUINV);
  82   }
  83   return 1;
  84 }
  85
  86 int tpiv_inverter_config_init(char *var, char *config, char *result)
  87 {
  88   char  *tmp ;
  89   char  *tok ;
  90   int    error ;
  91   char  *eq ;
  92   double value ;
  93   char  *endval ;
  94   char   token[256] ;
  95
  96   /* default config */
  97   tpiv_inverter_config_reverse = 1 ;
  98   tpiv_inverter_config_t0r=tpiv_inverter_config_t0f= 0.0 ;
  99
 100   if( !config )
 101     return 1;
 102
 103   tmp = alloca( sizeof( char ) * ( strlen( config )+1 ) );
 104   strcpy( tmp, config );
 105
 106   error = 0 ;
 107   tok = strtok( tmp, " "  );
 108   while( tok ) {
 109
 110     eq=strchr( tok, '=' );
 111     if( !eq ) { error=1 ; break ; }
 112     strncpy( token, tok, eq-tok ) ;
 113     token[ eq-tok ] = '\0' ;
 114     value = strtod( eq+1, &endval );
 115     if( ! ( *endval == ' ' || *endval == '\0' )  ) { error=1 ; break ; }
 116
 117     error = 1 ;
 118     if( !strcmp( token, "reverse" ) ) { tpiv_inverter_config_reverse = mbk_long_round(value) ; error = 0 ; }
 119     if( !strcmp( token, "t0"      ) ) { tpiv_inverter_config_t0r=tpiv_inverter_config_t0f=value ; error = 0 ; }
 120     if( !strcmp( token, "t0r"      ) ) { tpiv_inverter_config_t0r=value ; error = 0 ; }
 121     if( !strcmp( token, "t0f"      ) ) { tpiv_inverter_config_t0f=value ; error = 0 ; }
 122     if( !strcmp( token, "tmax"      ) ) { tpiv_inverter_config_tmax=value ; error = 0 ; }
 123     if( error )
 124       break ;
 125
 126     tok = strtok( NULL, " "  );
 127   }
 128
 129   if( error ) {
 130     printf( "bad configuration for %s\n", tok );
 131     return 0;
 132   }
 133   return 1;
 134 }
 135
 136
 137 int yagSimpleLatchDetection_init(char *var, char *val, char *result)
 138 {
 139   char buf[1024];
 140   char *c, *tok;
 141
 142   strcpy(buf, val);
 143   tok=strtok_r(buf, "+", &c);
 144   while (tok!=NULL)
 145     {
 146       if (strcasecmp(tok,"latch")!=0 && strcasecmp(tok,"memsym")!=0 && strcasecmp(tok,"levelhold")!=0 && strcasecmp(tok,"strictlevelhold")!=0)
 147        {
 148          avt_errmsg (AVT_ERRMSG, "041", AVT_WARNING, tok, var);
 149          return 0;
 150       }
 151       tok=strtok_r(NULL, "+", &c);
 152     }
 153   return 1;
 154 }
 155
 156 int yagDetectClockGating_init(char *var, char *val, char *result)
 157 {
 158   char buf[1024];
 159   char *c, *tok;
 160
 161   strcpy(buf, val);
 162   tok=strtok_r(buf, "+", &c);
 163   while (tok!=NULL)
 164     {
 165       if (strcasecmp(tok,"yes")!=0 && strcasecmp(tok,"no")!=0 && strcasecmp(tok,"check")!=0 && strcasecmp(tok,"filter")!=0)
 166        {
 167          avt_errmsg (AVT_ERRMSG, "041", AVT_WARNING, tok, var);
 168          return 0;
 169       }
 170       tok=strtok_r(NULL, "+", &c);
 171     }
 172   return 1;
 173 }
 174
 175
 176 // -----------------------------------------
 177 int TTV_MaxPathPeriodPrecharge=0;
 178 // mask: 1=latch, 2=precharge, 4=filter
 179 int TTV_IgnoreMaxFilter=0;
 180
 181 int avtTransparentPrecharge_init(char *var, char *val, int *result)
 182 {
 183   TTV_IgnoreMaxFilter&=~2;
 184   if (!strcasecmp (val, "yes")) *result=1, TTV_MaxPathPeriodPrecharge=1;
 185   else if (!strcasecmp (val, "no")) *result=0, TTV_MaxPathPeriodPrecharge=0;
 186   else if (!strcasecmp (val, "unfiltered")) *result=1, TTV_MaxPathPeriodPrecharge=1, TTV_IgnoreMaxFilter|=2;
 187   else {
 188       avt_errmsg (AVT_ERRMSG, "040", AVT_WARNING, val, var);
 189       return 0;
 190   }
 191   return 1;
 192 }
 193
 194 // -----------------------------------------
 195
 196 int ttvIgnoreMaxFilter_init(char *var, char *val, char *result)
 197 {
 198   char buf[1024];
 199   char *c, *tok;
 200
 201   TTV_IgnoreMaxFilter=0;
 202   strcpy(buf, val);
 203   tok=strtok_r(buf, " ", &c);
 204   while (tok!=NULL)
 205     {
 206       if (strcasecmp(tok,"latch")==0) TTV_IgnoreMaxFilter|=1;
 207       else if (strcasecmp(tok,"precharge")==0) TTV_IgnoreMaxFilter|=2;
 208       else if (strcasecmp(tok,"filter")==0) TTV_IgnoreMaxFilter|=4;
 209       else
 210       {
 211          avt_errmsg (AVT_ERRMSG, "040", AVT_WARNING, var, tok);
 212          return 0;
 213       }
 214       tok=strtok_r(NULL, " ", &c);
 215     }
 216   return 1;
 217 }
 218
 219 int avtParasiticCacheSize_init(char *var, char *val, char *result)
 220 {
 221   long oldval=RCN_CACHE_SIZE;
 222   char *ptend;
 223
 224   RCN_CACHE_SIZE = strtol( val, &ptend, 10 );
 225
 226   if( *ptend != '\0' ) {
 227     if( strcasecmp( ptend, "kb" )==0 )
 228       RCN_CACHE_SIZE = RCN_CACHE_SIZE * 1024;
 229     else {
 230       if( strcasecmp( ptend, "mb" )==0 )
 231         RCN_CACHE_SIZE = RCN_CACHE_SIZE * 1048576;
 232       else {
 233         if( strcasecmp( ptend, "gb" )==0 )
 234           RCN_CACHE_SIZE = RCN_CACHE_SIZE * 1073741824;
 235         else {
 236           avt_errmsg (AVT_ERRMSG, "040", AVT_WARNING, var, val);
 237           RCN_CACHE_SIZE = oldval;
 238         }
 239       }
 240     }
 241   }
 242   return 1;
 243 }
 244
 245 const struct {
 246   char *unit;
 247   double mult;
 248 } time_unit_tab[]={{"", 1},
 249               {"f", 1e-15},
 250               {"p", 1e-12},
 251               {"n", 1e-9},
 252               {"u", 1e-6},
 253               {"m", 1e-3},
 254               {"fs", 1e-15},
 255               {"ps", 1e-12},
 256               {"ns", 1e-9},
 257               {"us", 1e-6},
 258               {"ms", 1e-3},
 259               {"s", 1}};
 260 const struct {
 261   char *unit;
 262   double mult;
 263 } capa_unit_tab[]={{"", 1},
 264               {"ff", 1e-15},
 265               {"pf", 1e-12},
 266               {"f", 1e-15},
 267               {"p", 1e-12},
 268               {"n", 1e-9},
 269               {"u", 1e-6},
 270               {"m", 1e-3},
 271               {"nf", 1e-9},
 272               {"uf", 1e-6},
 273               {"mf", 1e-3},
 274               {"f", 1}};
 275 const struct {
 276   char *unit;
 277   double mult;
 278 } mem_unit_tab[]={{"", 1},
 279               {"b", 1},
 280               {"kb", 1024},
 281               {"mb", 1024*1024},
 282               {"gb", 1024*1024*1024}};
 283
 284 const struct {
 285   char *unit;
 286   double mult;
 287 } voltage_unit_tab[]={{"", 1},
 288               {"fv", 1e-15},
 289               {"pv", 1e-12},
 290               {"f", 1e-15},
 291               {"p", 1e-12},
 292               {"n", 1e-9},
 293               {"u", 1e-6},
 294               {"m", 1e-3},
 295               {"nv", 1e-9},
 296               {"uv", 1e-6},
 297               {"mv", 1e-3},
 298               {"v", 1}};
 299
 300 double avt_parse_unit(char *str, char type)
 301 {
 302   char    *nxt;
 303   unsigned int i;
 304   double val;
 305   if (type=='t')
 306   {
 307
 308     val=strtod(str, &nxt);
 309     if (*nxt!=';')
 310     {
 311       for (i=0; i<sizeof(time_unit_tab)/sizeof(*time_unit_tab); i++)
 312         if (strcasecmp(time_unit_tab[i].unit, nxt)==0) break;
 313
 314       if (i>=sizeof(time_unit_tab)/sizeof(*time_unit_tab))
 315       {
 316         avt_errmsg(AVT_ERRMSG, "049", AVT_FATAL, str);
 317       }
 318       else val*=time_unit_tab[i].mult;
 319     }
 320     else
 321       avt_errmsg(AVT_ERRMSG, "049", AVT_WARNING, str);
 322   }
 323   else if (type=='c')
 324   {
 325     val=strtod(str, &nxt);
 326     if (*nxt!=';')
 327     {
 328       for (i=0; i<sizeof(capa_unit_tab)/sizeof(*capa_unit_tab); i++)
 329         if (strcasecmp(capa_unit_tab[i].unit, nxt)==0) break;
 330
 331       if (i>=sizeof(capa_unit_tab)/sizeof(*capa_unit_tab))
 332       {
 333         avt_errmsg(AVT_API_ERRMSG, "006", AVT_FATAL, str);
 334       }
 335       else val*=capa_unit_tab[i].mult;
 336     }
 337     else
 338       avt_errmsg(AVT_ERRMSG, "049", AVT_WARNING, str);
 339   }
 340   else if (type=='m')
 341   {
 342     val=strtod(str, &nxt);
 343     if (*nxt!=';')
 344     {
 345       for (i=0; i<sizeof(mem_unit_tab)/sizeof(*mem_unit_tab); i++)
 346         if (strcasecmp(mem_unit_tab[i].unit, nxt)==0) break;
 347
 348       if (i>=sizeof(mem_unit_tab)/sizeof(*mem_unit_tab))
 349       {
 350         avt_errmsg(AVT_API_ERRMSG, "006", AVT_FATAL, str);
 351       }
 352       else val*=mem_unit_tab[i].mult;
 353     }
 354     else
 355       avt_errmsg(AVT_ERRMSG, "049", AVT_WARNING, str);
 356   }
 357   else if (type=='v')
 358   {
 359     val=strtod(str, &nxt);
 360     if (*nxt!=';')
 361     {
 362       for (i=0; i<sizeof(voltage_unit_tab)/sizeof(*voltage_unit_tab); i++)
 363         if (strcasecmp(voltage_unit_tab[i].unit, nxt)==0) break;
 364
 365       if (i>=sizeof(voltage_unit_tab)/sizeof(*voltage_unit_tab))
 366       {
 367         avt_errmsg(AVT_API_ERRMSG, "006", AVT_FATAL, str);
 368       }
 369       else val*=voltage_unit_tab[i].mult;
 370     }
 371     else
 372       avt_errmsg(AVT_ERRMSG, "049", AVT_WARNING, str);
 373   }
 374   else
 375     avt_errmsg(AVT_API_ERRMSG, "006", AVT_FATAL, str);
 376
 377   return val;
 378 }
 379
 380 int avt_parse_time (char *var, char *val, float *result)
 381 {
 382   *result=avt_parse_unit(val, 't');
 383   return 1;
 384 }
 385
 386 int avt_parse_capa (char *var, char *val, float *result)
 387 {
 388   *result=avt_parse_unit(val, 'c');
 389   return 1;
 390 }
 391 int avt_parse_mem (char *var, char *val, float *result)
 392 {
 393   *result=avt_parse_unit(val, 'm');
 394   return 1;
 395 }
 396
 397 void avt_init_model(chain_list **list, char *str)
 398 {
 399   char buf[1024];
 400   char *tmp, *pttok;
 401   freechain(*list); *list=NULL;
 402   if (namealloc_ok() && str!=NULL && strlen(str)>0)
 403   {
 404     strcpy(buf, str);
 405     *list = addchain(*list, namealloc(strtok_r(buf, ":", &tmp)));
 406     while ((pttok = strtok_r(NULL, ":", &tmp)))
 407       *list = addchain(*list, namealloc(pttok));
 408   }
 409 }
 410
 411 int avt_init_model_tn (char *var, char *val, char *result)
 412 {
 413   avt_init_model(&TNMOS, val);
 414   result=NULL; var=NULL;
 415   return 1;
 416 }
 417 int avt_init_model_tp (char *var, char *val, char *result)
 418 {
 419   avt_init_model(&TPMOS, val);
 420   result=NULL; var=NULL;
 421   return 1;
 422 }
 423 int avt_init_model_dn (char *var, char *val, char *result)
 424 {
 425   avt_init_model(&DNMOS, val);
 426   result=NULL; var=NULL;
 427   return 1;
 428 }
 429 int avt_init_model_dp (char *var, char *val, char *result)
 430 {
 431   avt_init_model(&DPMOS, val);
 432   result=NULL; var=NULL;
 433   return 1;
 434 }
 435