distrib/sources/tas/stm/stm_mod_modif.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit: STM Version 1.00                                             */
   6 /*    Fichier: stm_mod_modif.c                                              */
   7 /*                                                                          */
   8 /*    (c) copyright 2000 AVERTEC                                            */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s): Gilles Augustins                                           */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 /****************************************************************************/
  16 /*     includes                                                             */
  17 /****************************************************************************/
  18
  19 #include "stm.h"
  20
  21 /****************************************************************************/
  22 /*     functions                                                            */
  23 /****************************************************************************/
  24
  25 timing_model *stm_mod_Creduce (char *name, timing_model *tmodel, float slew, float ckslew, char redmode)
  26 {
  27     timing_model *rcstrmod;
  28     timing_model *tmodel_tbl;
  29
  30     if (!tmodel)
  31         return NULL;
  32
  33     switch (tmodel->UTYPE) {
  34         case STM_MOD_MODNULL:
  35             rcstrmod = NULL;
  36             break;
  37         case STM_MOD_MODSCM:
  38             rcstrmod = stm_mod_create (name);
  39             stm_mod_update (rcstrmod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
  40             stm_mod_update_transition(rcstrmod, tmodel->TTYPE);
  41             tmodel_tbl = stm_mod_duplicate (NULL, tmodel);
  42             stm_mod_defaultscm2tbl_delay (tmodel_tbl, -1.0, -1.0);
  43             rcstrmod->UMODEL.TABLE = stm_modtbl_Creduce (tmodel_tbl->UMODEL.TABLE, slew, ckslew, redmode);
  44             rcstrmod->UTYPE = STM_MOD_MODTBL;
  45             stm_mod_destroy (tmodel_tbl);
  46             break;
  47         case STM_MOD_MODPLN:
  48             rcstrmod = stm_mod_create (name);
  49             stm_mod_update (rcstrmod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
  50             stm_mod_update_transition(rcstrmod, tmodel->TTYPE);
  51             tmodel_tbl = stm_mod_duplicate (NULL, tmodel);
  52             stm_mod_defaultpln2tbl_delay (tmodel_tbl);
  53             rcstrmod->UMODEL.TABLE = stm_modtbl_Creduce (tmodel_tbl->UMODEL.TABLE, slew, ckslew, redmode);
  54             rcstrmod->UTYPE = STM_MOD_MODTBL;
  55             stm_mod_destroy (tmodel_tbl);
  56             break;
  57         case STM_MOD_MODTBL:
  58             rcstrmod = stm_mod_create (name);
  59             stm_mod_update (rcstrmod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
  60             stm_mod_update_transition(rcstrmod, tmodel->TTYPE);
  61             rcstrmod->UMODEL.TABLE = stm_modtbl_Creduce (tmodel->UMODEL.TABLE, slew, ckslew, redmode);
  62             rcstrmod->UTYPE = STM_MOD_MODTBL;
  63             break;
  64         case STM_MOD_MODFCT:
  65             fprintf (stderr, " - warning - stm_mod_Creduce: STM_MOD_MODFCT not implemented\n");
  66             break;
  67     }
  68     return rcstrmod;
  69 }
  70
  71 /****************************************************************************/
  72
  73 timing_model *stm_mod_reduce (char *name, timing_model *tmodel, float slew, float load, char redmode, char modeltype)
  74
  75 {
  76     timing_model *rdelaymod;
  77     timing_model *tmodel_tbl;
  78
  79     if (!tmodel)
  80         return NULL;
  81
  82     switch (tmodel->UTYPE) {
  83         case STM_MOD_MODNULL:
  84             rdelaymod = NULL;
  85             break;
  86         case STM_MOD_MODSCM:
  87             rdelaymod = stm_mod_create (name);
  88             stm_mod_update (rdelaymod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
  89             stm_mod_update_transition(rdelaymod, tmodel->TTYPE);
  90             tmodel_tbl = stm_mod_duplicate (NULL, tmodel);
  91             if(modeltype == STM_DELAY){
  92                 if (redmode == STM_SLEWFIX_RED) {
  93                     stm_mod_defaultscm2tbl_delay (tmodel_tbl, slew, -1.0);
  94                 }else if (redmode == STM_LOADFIX_RED) {
  95                     stm_mod_defaultscm2tbl_delay (tmodel_tbl, -1.0, load);
  96                 }else {
  97                     stm_mod_defaultscm2tbl_delay (tmodel_tbl, -1.0, -1.0);
  98                 }
  99             }else{
 100                 if (redmode == STM_SLEWFIX_RED) {
 101                     stm_mod_defaultscm2tbl_slew (tmodel_tbl, slew, -1.0);
 102                 }else if (redmode == STM_LOADFIX_RED) {
 103                     stm_mod_defaultscm2tbl_slew (tmodel_tbl, -1.0, load);
 104                 }else{
 105                     stm_mod_defaultscm2tbl_slew (tmodel_tbl, -1.0, -1.0);
 106                 }
 107             }
 108             rdelaymod->UMODEL.TABLE = stm_modtbl_reduce (tmodel_tbl->UMODEL.TABLE, slew, load, redmode);
 109             rdelaymod->UTYPE = STM_MOD_MODTBL;
 110             stm_mod_destroy (tmodel_tbl);
 111             break;
 112         case STM_MOD_MODPLN:
 113             rdelaymod = stm_mod_create (name);
 114             stm_mod_update (rdelaymod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
 115             stm_mod_update_transition(rdelaymod, tmodel->TTYPE);
 116             tmodel_tbl = stm_mod_duplicate (NULL, tmodel);
 117             if(modeltype == STM_DELAY)
 118                 stm_mod_defaultpln2tbl_delay (tmodel_tbl);
 119             else
 120                 stm_mod_defaultpln2tbl_slew (tmodel_tbl);
 121             rdelaymod->UMODEL.TABLE = stm_modtbl_reduce (tmodel_tbl->UMODEL.TABLE, slew, load, redmode);
 122             rdelaymod->UTYPE = STM_MOD_MODTBL;
 123             stm_mod_destroy (tmodel_tbl);
 124             break;
 125         case STM_MOD_MODTBL:
 126             rdelaymod = stm_mod_create (name);
 127             stm_mod_update (rdelaymod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
 128             stm_mod_update_transition(rdelaymod, tmodel->TTYPE);
 129             rdelaymod->UMODEL.TABLE = stm_modtbl_reduce (tmodel->UMODEL.TABLE, slew, load, redmode);
 130             rdelaymod->UTYPE = STM_MOD_MODTBL;
 131             break;
 132         case STM_MOD_MODFCT:
 133             rdelaymod = stm_mod_create (name);
 134             stm_mod_update (rdelaymod, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VF);
 135             tmodel_tbl = stm_mod_duplicate (NULL, tmodel);
 136             stm_mod_defaultfct2tbl_delay (tmodel_tbl, ~STM_NOTYPE, ~STM_NOTYPE);
 137             rdelaymod->UMODEL.TABLE = stm_modtbl_reduce (tmodel_tbl->UMODEL.TABLE, slew, load, redmode);
 138             rdelaymod->UTYPE = STM_MOD_MODTBL;
 139             stm_mod_destroy (tmodel_tbl);
 140
 141 //            fprintf (stderr, " - warning - stm_mod_reduce: STM_MOD_MODFCT not implemented\n");
 142             break;
 143     }
 144     return rdelaymod;
 145 }
 146
 147 /****************************************************************************/
 148
 149 void stm_mod_shift (timing_model *model, float load)
 150 {
 151     if (model)
 152         switch (model->UTYPE) {
 153             case STM_MOD_MODTBL:
 154                 stm_modtbl_shift (model->UMODEL.TABLE, load);
 155                 break;
 156             case STM_MOD_MODSCM:
 157                 avt_errmsg (STM_ERRMSG,"031", AVT_ERROR);
 158                 break;
 159             case STM_MOD_MODPLN:
 160                 avt_errmsg (STM_ERRMSG,"023", AVT_ERROR);
 161                 break;
 162             case STM_MOD_MODFCT:
 163                 fprintf (stderr, " - warning - stm_mod_shift: STM_MOD_MODFCT not implemented\n");
 164                 break;
 165         }
 166 }
 167
 168 /****************************************************************************/
 169
 170 void stm_mod_shrinkslewaxis (timing_model *model, double thmin, double thmax, int type)
 171 {
 172     return; /* edge normalisation */
 173     if (model)
 174         switch (model->UTYPE) {
 175             case STM_MOD_MODTBL:
 176                 stm_modtbl_shrinkslewaxis (model->UMODEL.TABLE, thmin, thmax, type);
 177                 break;
 178             case STM_MOD_MODSCM:
 179                 break;
 180             case STM_MOD_MODPLN:
 181                 break;
 182             case STM_MOD_MODFCT:
 183                 break;
 184         }
 185 }
 186
 187 /****************************************************************************/
 188
 189 void stm_mod_shrinkslewaxis_with_rate (timing_model *model, double rate)
 190 {
 191     if (model)
 192         switch (model->UTYPE) {
 193             case STM_MOD_MODTBL:
 194                 stm_modtbl_shrinkslewaxis_with_rate (model->UMODEL.TABLE, rate);
 195                 break;
 196             case STM_MOD_MODSCM:
 197                 break;
 198             case STM_MOD_MODPLN:
 199                 break;
 200             case STM_MOD_MODFCT:
 201                 break;
 202         }
 203 }
 204
 205 /****************************************************************************/
 206
 207 void stm_mod_shrinkslewdata (timing_model *model, double thmin, double thmax, int type)
 208 {
 209     return; /* edge normalisation */
 210     if (model)
 211         switch (model->UTYPE) {
 212             case STM_MOD_MODTBL:
 213                 stm_modtbl_shrinkslewdata (model->UMODEL.TABLE, thmin, thmax, type);
 214                 break;
 215             case STM_MOD_MODSCM:
 216                 break;
 217             case STM_MOD_MODPLN:
 218                 break;
 219             case STM_MOD_MODFCT:
 220                 break;
 221         }
 222 }
 223
 224 /****************************************************************************/
 225
 226 void stm_mod_shrinkslewdata_with_rate (timing_model *model, double rate)
 227 {
 228     if (model)
 229         switch (model->UTYPE) {
 230             case STM_MOD_MODTBL:
 231                 stm_modtbl_shrinkslewdata_with_rate (model->UMODEL.TABLE, rate);
 232                 break;
 233             case STM_MOD_MODSCM:
 234                 break;
 235             case STM_MOD_MODPLN:
 236                 break;
 237             case STM_MOD_MODFCT:
 238                 break;
 239         }
 240 }
 241
 242 /****************************************************************************/
 243
 244 timing_model *stm_mod_neg (timing_model *model)
 245 {
 246     timing_model *n_model = NULL;
 247
 248     if (!model)
 249         return NULL;
 250
 251     switch (model->UTYPE) {
 252         case STM_MOD_MODTBL:
 253             n_model = stm_mod_create (NULL);
 254             n_model->UMODEL.TABLE = stm_modtbl_neg (model->UMODEL.TABLE);
 255             n_model->UTYPE = STM_MOD_MODTBL;
 256             break;
 257         case STM_MOD_MODSCM:
 258             n_model = NULL;
 259             break;
 260         case STM_MOD_MODPLN:
 261             n_model = NULL;
 262             break;
 263         case STM_MOD_MODFCT:
 264             n_model = NULL;
 265             break;
 266     }
 267
 268     return n_model;
 269 }