psdk_cust/pdk_k2g_1_0_1_2_eng/packages/ti/board/diag/nand/src/evmk2g_elm.h

   1 /*
   2  * Copyright (c) 2016, Texas Instruments Incorporated
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * *  Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * *  Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * *  Neither the name of Texas Instruments Incorporated nor the names of
  17  *    its contributors may be used to endorse or promote products derived
  18  *    from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33
  34 /**
  35  * \file      evmk2g_elm.h
  36  *
  37  * \brief     This file contains ELM specific structure, typedefs, function
  38  *            prototypes.
  39  *
  40  */
  41
  42 #ifndef _EVMK2G_ELM_H_
  43 #define _EVMK2G_ELM_H_
  44
  45 /*******************************************************************************
  46 *                           MACRO DEFINITIONS
  47 *******************************************************************************/
  48 /*****************************************************************************/
  49
  50 /**
  51  *  \brief Macros which can be used as 'configVal' parameter
  52  *         to elmAutoGatingConfig API
  53  */
  54 /** OCP clock is free-running */
  55 #define ELM_AUTOGATING_OCP_FREE                       (0)
  56 /** Automatic internal OCP clock gating strategy is applied
  57     based on the OCP interface activity */
  58 #define ELM_AUTOGATING_OCP_GATING                     (1)
  59
  60 /**
  61  *  \brief Macros which can be used as 'configVal' parameter
  62  *         to elmIdleModeSelect API.
  63  */
  64 /** For selecting force-idle mode */
  65 #define ELM_IDLEMODE_FORCEIDLE                        (0)
  66 /** For selecting no-idle mode */
  67 #define ELM_IDLEMODE_NOIDLE                           (1)
  68 /** For selecting smart-idle mode */
  69 #define ELM_IDLEMODE_SMARTIDLE                        (2)
  70
  71 /**
  72  *  \brief Macros which can be used as 'configVal' parameter
  73  *         to elmOCPClkActivityConfig API.
  74  */
  75 /** OCP Clock is maintained during wake up period */
  76 #define ELM_CLOCKACTIVITYOCP_OCP_ON                   (1)
  77 /** OCP clock is switch off */
  78 #define ELM_CLOCKACTIVITYOCP_OCP_OFF                  (0)
  79
  80 /**
  81  *  \brief Macros which can be used as 'flag' parameter to elmIntStatusGet API.
  82  */
  83 /** Error-location status for syndrome polynomial 0 */
  84 #define ELM_LOC_VALID_0_STATUS                        (0)
  85 /** Error-location status for syndrome polynomial 1 */
  86 #define ELM_LOC_VALID_1_STATUS                        (1)
  87 /** Error-location status for syndrome polynomial 2 */
  88 #define ELM_LOC_VALID_2_STATUS                        (2)
  89 /** Error-location status for syndrome polynomial 3 */
  90 #define ELM_LOC_VALID_3_STATUS                        (3)
  91 /** Error-location status for syndrome polynomial 4 */
  92 #define ELM_LOC_VALID_4_STATUS                        (4)
  93 /** Error-location status for syndrome polynomial 5 */
  94 #define ELM_LOC_VALID_5_STATUS                        (5)
  95 /** Error-location status for syndrome polynomial 6 */
  96 #define ELM_LOC_VALID_6_STATUS                        (6)
  97 /** Error-location status for syndrome polynomial 7 */
  98 #define ELM_LOC_VALID_7_STATUS                        (7)
  99 /** Error-location status for a full page */
 100 #define ELM_PAGE_VALID_STATUS                         (8)
 101
 102 /**
 103  *  \brief Macros which can be used as 'flag' parameter to elmIntConfig API.
 104  */
 105 /** Enables ELM interrupts */
 106 #define ELM_INT_ENALBLE                               (1)
 107 /** Disables ELM interrupts */
 108 #define ELM_INT_DISALBLE                              (0)
 109
 110 /**
 111  *  \brief Macros which can be used as 'bchECCLevel' parameter to
 112  *         elmErrCorrectionLevelSet API.
 113  */
 114 /** BCH level for Upto 4 bits error correction */
 115 #define ELM_ECC_BCH_LEVEL_4BITS                       (0)
 116 /** BCH level for Upto 8 bits error correction */
 117 #define ELM_ECC_BCH_LEVEL_8BITS                       (1)
 118 /** BCH level for Upto 16 bits error correction */
 119 #define ELM_ECC_BCH_LEVEL_16BITS                      (2)
 120
 121 /**
 122  *  \brief Macros which can be used as 'mode' parameter to elmModeSet API.
 123  */
 124 /** Enables continuous mode of ELM module */
 125 #define ELM_MODE_CONTINUOUS                           (0)
 126 /** Enables page mode of ELM module */
 127 #define ELM_MODE_PAGE                                 (1)
 128
 129 /**
 130  *  \brief Macros which can be used as 'sectorNum' parameter to elmModeSet API.
 131  */
 132 /** For selecting syndrome polynomial 0 as part of the page in page mode */
 133 #define ELM_PAGEMODE_SECTOR_0                         (0)
 134 /** For selecting syndrome polynomial 1 as part of the page in page mode */
 135 #define ELM_PAGEMODE_SECTOR_1                         (1)
 136 /** For selecting syndrome polynomial 2 as part of the page in page mode */
 137 #define ELM_PAGEMODE_SECTOR_2                         (2)
 138 /** For selecting syndrome polynomial 3 as part of the page in page mode */
 139 #define ELM_PAGEMODE_SECTOR_3                         (3)
 140 /** For selecting syndrome polynomial 4 as part of the page in page mode */
 141 #define ELM_PAGEMODE_SECTOR_4                         (4)
 142 /** For selecting syndrome polynomial 5 as part of the page in page mode */
 143 #define ELM_PAGEMODE_SECTOR_5                         (5)
 144 /** For selecting syndrome polynomial 6 as part of the page in page mode */
 145 #define ELM_PAGEMODE_SECTOR_6                         (6)
 146 /** For selecting syndrome polynomial 7 as part of the page in page mode */
 147 #define ELM_PAGEMODE_SECTOR_7                         (7)
 148
 149 /**
 150  *  \brief Macros which can be used as 'synFrgmtId' parameter to
 151  *         elmSyndromeFrgmtSet API
 152  */
 153 /** Selects syndrome fragment 0 for error-location processing */
 154 #define ELM_SYNDROME_FRGMT_0                          (0)
 155 /** Selects syndrome fragment 1 for error-location processing */
 156 #define ELM_SYNDROME_FRGMT_1                          (1)
 157 /** Selects syndrome fragment 2 for error-location processing */
 158 #define ELM_SYNDROME_FRGMT_2                          (2)
 159 /** Selects syndrome fragment 3 for error-location processing */
 160 #define ELM_SYNDROME_FRGMT_3                          (3)
 161 /** Selects syndrome fragment 4 for error-location processing */
 162 #define ELM_SYNDROME_FRGMT_4                          (4)
 163 /** Selects syndrome fragment 5 for error-location processing */
 164 #define ELM_SYNDROME_FRGMT_5                          (5)
 165 /** Selects syndrome fragment 6 for error-location processing */
 166 #define ELM_SYNDROME_FRGMT_6                          (6)
 167
 168 /**
 169  *  \brief Macros which can be used as 'errNum' parameter to
 170  *         elmErrLocBitAddrGet API.
 171  */
 172 /** Indicates 0th error of ELM */
 173 #define ELM_ERROR_NUM_0                               (0)
 174 /** Indicates 1st error of ELM */
 175 #define ELM_ERROR_NUM_1                               (1)
 176 /** Indicates 2nd error of ELM */
 177 #define ELM_ERROR_NUM_2                               (2)
 178 /** Indicates 3rd error of ELM */
 179 #define ELM_ERROR_NUM_3                               (3)
 180 /** Indicates 4th error of ELM */
 181 #define ELM_ERROR_NUM_4                               (4)
 182 /** Indicates 5th error of ELM */
 183 #define ELM_ERROR_NUM_5                               (5)
 184 /** Indicates 6th error of ELM */
 185 #define ELM_ERROR_NUM_6                               (6)
 186 /** Indicates 7th error of ELM */
 187 #define ELM_ERROR_NUM_7                               (7)
 188 /** Indicates 8th error of ELM */
 189 #define ELM_ERROR_NUM_8                               (8)
 190 /** Indicates 9th error of ELM */
 191 #define ELM_ERROR_NUM_9                               (9)
 192 /** Indicates 10th error of ELM */
 193 #define ELM_ERROR_NUM_10                              (10)
 194 /** Indicates 11th error of ELM */
 195 #define ELM_ERROR_NUM_11                              (11)
 196 /** Indicates 12th error of ELM */
 197 #define ELM_ERROR_NUM_12                              (12)
 198 /** Indicates 13th error of ELM */
 199 #define ELM_ERROR_NUM_13                              (13)
 200 /** Indicates 14th error of ELM */
 201 #define ELM_ERROR_NUM_14                              (14)
 202 /** Indicates 15th error of ELM */
 203 #define ELM_ERROR_NUM_15                              (15)
 204
 205 /** Sets a bit of ELM register to high */
 206 #define ELM_BIT_SET_HIGH        (1)
 207 /** Sets a bit of ELM register to low */
 208 #define ELM_BIT_SET_LOW         (0)
 209
 210 /** Enables a bit of ELM register */
 211 #define ELM_BIT_ENABLE          (1)
 212 /** Disables a bit of ELM register */
 213 #define ELM_BIT_DISABLE         (0)
 214
 215 /** Handle to access ELM registers. */
 216 #define hElmCfg  ((CSL_elmRegs *)CSL_ELM_0_CFG_REGS)
 217
 218 /** ELM Handle */
 219 typedef CSL_elmRegs * elmHandle;
 220
 221 /*****************************************************************************
 222 **                    FUNCTION PROTOTYPES
 223 *****************************************************************************/
 224
 225 /**
 226 * \brief   This function reads the IP revision code of ELM.\n
 227 *
 228 * \param   hElm    ELM handle for accessing HW registers.\n
 229 *
 230 * \return  ipRev    IP revision code of ELM.\n
 231 */
 232 Uint32 elmRevisionGet(elmHandle hElm);
 233
 234 /**
 235 * \brief   This function configs the Internal OCP clock gating strategy.\n
 236 *
 237 * \param   hElm           ELM handle for accessing HW registers.\n
 238 *
 239 * \param   configVal      Config value for OCP clk gating.\n
 240 *                         This can take one of the following values :\n
 241 *                         ELM_AUTOGATING_OCP_FREE   -- OCP clock is free-running\n
 242 *                         ELM_AUTOGATING_OCP_GATING -- Automatic internal OCP
 243 *                                                      clock gating strategy is
 244 *                                                      applied based on the OCP
 245 *                                                      interface activity.\n
 246 *
 247 * \return  none.\n
 248 */
 249 void elmAutoGatingConfig(elmHandle hElm, Uint32 configVal);
 250
 251 /**
 252 * \brief   This function sets the idle mode for ELM.\n
 253 *
 254 * \param   hElm           ELM handle for accessing HW registers.\n
 255 *
 256 * \param   mode           Idle mode.\n
 257 *                         This can take one of the following values :\n
 258 *                         ELM_IDLEMODE_FORCEIDLE -- for force-idle. \n
 259 *                         ELM_IDLEMODE_NOIDLE    -- for no-idle. \n
 260 *                         ELM_IDLEMODE_SMARTIDLE -- for smart-idle.\n
 261 *
 262 * \return  none.\n
 263 */
 264 void elmIdleModeSelect(elmHandle hElm, Uint32 mode);
 265
 266 /**
 267 * \brief   This function Resets the ELM.\n
 268 *
 269 * \param   hElm       ELM handle for accessing HW registers.\n
 270 *
 271 * \return  None.\n
 272 */
 273 void elmModuleReset(elmHandle hElm);
 274
 275 /**
 276 * \brief   This function sets the OCP Clock activity when module is in IDLE
 277 *          mode.\n
 278 *
 279 * \param   hElm           ELM handle for accessing HW registers.\n
 280 *
 281 * \param   configVal      Config value.\n
 282 *                         This can take one of the following values :\n
 283 *                         ELM_CLOCKACTIVITYOCP_OCP_OFF -- OCP clock is swith off\n
 284 *                         ELM_CLOCKACTIVITYOCP_OCP_ON  -- OCP Clock is
 285 *                                                         maintained during
 286 *                                                         wake up period.\n
 287 *
 288 * \return  none.\n
 289 */
 290 void elmOCPClkActivityConfig(elmHandle hElm, Uint32 configVal);
 291
 292 /**
 293 * \brief   This function gets the software resets status of ELM.\n
 294 *
 295 * \param   hElm       ELM handle for accessing HW registers.\n
 296 *
 297 * \return  status     Reset status : \n
 298 *                       0 : Module reset is on-going.\n
 299 *                       1 : Module reset is completed.\n
 300 */
 301 Uint32 elmModuleResetStatusGet(elmHandle hElm);
 302
 303 /**
 304 * \brief   This function gets Interrupt status.\n
 305 *
 306 * \param   hElm           ELM handle for accessing HW registers.\n
 307 *
 308 * \param   flag           Flag for which interrupt status has to get.\n
 309 *                         This can take one of the following values :\n
 310 *                         ELM_LOC_VALID_0_STATUS         : Error-location
 311 *                                                          status for syndrome
 312 *                                                          polynomial 0.\n
 313 *                         ELM_LOC_VALID_1_STATUS         : Error-location
 314 *                                                          status for syndrome
 315 *                                                          polynomial 1.\n
 316 *                         ELM_LOC_VALID_2_STATUS         : Error-location
 317 *                                                          status for syndrome
 318 *                                                          polynomial 2.\n
 319 *                         ELM_LOC_VALID_3_STATUS         : Error-location
 320 *                                                          status for syndrome
 321 *                                                          polynomial 3.\n
 322 *                         ELM_LOC_VALID_4_STATUS         : Error-location
 323 *                                                          status for syndrome
 324 *                                                          polynomial 4.\n
 325 *                         ELM_LOC_VALID_5_STATUS         : Error-location
 326 *                                                          status for syndrome
 327 *                                                          polynomial 5.\n
 328 *                         ELM_LOC_VALID_6_STATUS         : Error-location
 329 *                                                          status for syndrome
 330 *                                                          polynomial 6.\n
 331 *                         ELM_LOC_VALID_7_STATUS         : Error-location
 332 *                                                          status for syndrome
 333 *                                                          polynomial 7.\n
 334 *                         ELM_PAGE_VALID_STATUS          : Error-location
 335 *                                                          status for a full
 336 *                                                          page. \n
 337 *
 338 * \return  intSts         Interrupt Status. Return value meaning depends on the
 339 *                         param flag. \n
 340 *                         If flag is ELM_LOC_VALID_i_STATUS where i = 0 to 7,
 341 *                         then\n
 342 *                            0 : No syndrome processed or process in progress.\n
 343 *                            1 : Error-location process completed.\n
 344 *
 345 *                         If flag is ELM_PAGE_VALID_STATUS, then\n
 346 *                            0 : Error locations invalid for all polynomials
 347 *                                enabled.\n
 348 *                            1 : All error locations valid.\n
 349 *
 350 */
 351 Uint32 elmIntStatusGet(elmHandle hElm, Uint32 flag);
 352
 353 /**
 354 * \brief   This function clears the interrupt.\n
 355 *
 356 * \param   hElm           ELM handle for accessing HW registers.\n
 357 *
 358 * \param   flag           Flag for which interrupt status has to clear.\n
 359 *                         This can take one of the following values :\n
 360 *                         ELM_LOC_VALID_0_STATUS        : Error-location
 361 *                                                         interrupt for syndrome
 362 *                                                         polynomial 0.\n
 363 *                         ELM_LOC_VALID_1_STATUS        : Error-location
 364 *                                                         interrupt for syndrome
 365 *                                                         polynomial 1.\n
 366 *                         ELM_LOC_VALID_2_STATUS        : Error-location
 367 *                                                         interrupt for syndrome
 368 *                                                         polynomial 2.\n
 369 *                         ELM_LOC_VALID_3_STATUS        : Error-location
 370 *                                                         interrupt for syndrome
 371 *                                                         polynomial 3.\n
 372 *                         ELM_LOC_VALID_4_STATUS        : Error-location
 373 *                                                         interrupt for syndrome
 374 *                                                         polynomial 4.\n
 375 *                         ELM_LOC_VALID_5_STATUS        : Error-location
 376 *                                                         interrupt for syndrome
 377 *                                                         polynomial 5.\n
 378 *                         ELM_LOC_VALID_6_STATUS        : Error-location
 379 *                                                         interrupt for syndrome
 380 *                                                         polynomial 6.\n
 381 *                         ELM_LOC_VALID_7_STATUS        : Error-location
 382 *                                                         interrupt for syndrome
 383 *                                                         polynomial 7.\n
 384 *                         ELM_PAGE_VALID_STATUS         : Error-location
 385 *                                                         interrupt for a full
 386 *                                                         page.\n
 387 *
 388 * \return  None. \n
 389 *
 390 */
 391 void elmIntStatusClear(elmHandle hElm, Uint32 flag);
 392
 393 /**
 394 * \brief   This function configs i.e enables or disables the interrupts.\n
 395 *
 396 * \param   hElm           ELM handle for accessing HW registers.\n
 397 *
 398 * \param   intflag        intFlag for which interrupt has to config.\n
 399 *                         This can take one of the following values :\n
 400 *                         ELM_LOC_VALID_0_STATUS        : Error-location
 401 *                                                         interrupt for syndrome
 402 *                                                         polynomial 0.\n
 403 *                         ELM_LOC_VALID_1_STATUS        : Error-location
 404 *                                                         interrupt for syndrome
 405 *                                                         polynomial 1.\n
 406 *                         ELM_LOC_VALID_2_STATUS        : Error-location
 407 *                                                         interrupt for syndrome
 408 *                                                         polynomial 2.\n
 409 *                         ELM_LOC_VALID_3_STATUS        : Error-location
 410 *                                                         interrupt for syndrome
 411 *                                                         polynomial 3.\n
 412 *                         ELM_LOC_VALID_4_STATUS        : Error-location
 413 *                                                         interrupt for syndrome
 414 *                                                         polynomial 4.\n
 415 *                         ELM_LOC_VALID_5_STATUS        : Error-location
 416 *                                                         interrupt for syndrome
 417 *                                                         polynomial 5.\n
 418 *                         ELM_LOC_VALID_6_STATUS        : Error-location
 419 *                                                         interrupt for syndrome
 420 *                                                         polynomial 6.\n
 421 *                         ELM_LOC_VALID_7_STATUS        : Error-location
 422 *                                                         interrupt for syndrome
 423 *                                                         polynomial 7.\n
 424 *                         ELM_PAGE_VALID_STATUS         : Error-location
 425 *                                                         interrupt for a full
 426 *                                                         page. \n
 427 *
 428 * \param   configVal     Config Value.\n
 429 *                        This can take one of the following values :\n
 430 *                        ELM_INT_ENALBLE                : To enble the interrupt\n
 431 *                        ELM_INT_DISALBLE               : To disable the
 432 *                                                         interrupt.\n
 433 * \return  None. \n
 434 *
 435 */
 436 void elmIntConfig(elmHandle hElm, Uint32 intFlag, Uint32 configVal);
 437
 438 /**
 439 * \brief   This function sets the Error correction level for BCH alogorithm.\n
 440 *
 441 * \param   hElm           ELM handle for accessing HW registers.\n
 442 *
 443 * \param   bchECCLevel    BCH error correction level.\n
 444 *                         This can take one of the following values :\n
 445 *                         ELM_ECC_BCH_LEVEL_16BITS    : For Upto 16 bits error
 446 *                                                       correction.\n
 447 *                         ELM_ECC_BCH_LEVEL_8BITS     : For Upto 8 bits error
 448 *                                                       correction.\n
 449 *                         ELM_ECC_BCH_LEVEL_4BITS     : For Upto 4 bits error
 450 *                                                       correction.\n
 451 *
 452 * \return  None. \n
 453 *
 454 */
 455 void elmErrCorrectionLevelSet(elmHandle hElm, Uint32 bchECCLevel);
 456
 457 /**
 458 * \brief   This function sets the size of the buffers for which
 459 *          the error-location engine is used.\n
 460 *
 461 * \param   hElm       ELM handle for accessing HW registers.\n
 462 *
 463 * \param   eccSize    eccSize in number of nibbles (i.e 4-bits entities).\n
 464 *
 465 * \return  None. \n
 466 *
 467 */
 468 void elmECCSizeSet(elmHandle hElm, Uint32 eccSize);
 469
 470 /**
 471 * \brief   This function sets mode of the ELM module.\n
 472 *
 473 * \param   hElm           ELM handle for accessing HW registers.\n
 474 * \param   mode           mode of the ELM.\n
 475 *                         This can take one of the following values :\n
 476 *                         ELM_MODE_PAGE       -- For page mode.\n
 477 *                         ELM_MODE_CONTINUOUS -- For continuous mode.\n
 478 *
 479 * \param   sectorNum      Sector number or syndrome polynomial number which has
 480 *                         to select as part of the page in page mode.\n
 481 *                         This can take one of the following values :\n
 482 *                         ELM_PAGEMODE_SECTOR_0 -- For selecting syndrome
 483 *                                                  polynomial 0 as part of the
 484 *                                                  page in page mode.\n
 485 *                         ELM_PAGEMODE_SECTOR_1 -- For selecting syndrome
 486 *                                                  polynomial 1 as part of the
 487 *                                                  page in page mode.\n
 488 *                         ELM_PAGEMODE_SECTOR_2 -- For selecting syndrome
 489 *                                                  polynomial 2 as part of the
 490 *                                                  page in page mode.\n
 491 *                         ELM_PAGEMODE_SECTOR_3 -- For selecting syndrome
 492 *                                                  polynomial 3 as part of the
 493 *                                                  page in page mode.\n
 494 *                         ELM_PAGEMODE_SECTOR_4 -- For selecting syndrome
 495 *                                                  polynomial 4 as part of the
 496 *                                                  page in page mode.\n
 497 *                         ELM_PAGEMODE_SECTOR_5 -- For selecting syndrome
 498 *                                                  polynomial 5 as part of the
 499 *                                                  page in page mode.\n
 500 *                         ELM_PAGEMODE_SECTOR_6 -- For selecting syndrome
 501 *                                                  polynomial 6 as part of the
 502 *                                                  page in page mode.\n
 503 *                         ELM_PAGEMODE_SECTOR_7 -- For selecting syndrome
 504 *                                                  polynomial 7 as part of the
 505 *                                                  page in page mode.\n
 506
 507 * \return  None. \n
 508 *
 509 */
 510 void elmModeSet(elmHandle hElm, Uint32 mode, Uint32 sectorNum);
 511
 512 /**
 513 * \brief   This function sets the fragments of syndrome polynomial for
 514 *          error-location processing.\n
 515 *
 516 * \param   hElm           ELM handle for accessing HW registers.\n
 517 *
 518 * \param   synFrgmtId     Syndrome fragment ID.\n
 519 *                         This can take one of the following values :\n
 520 *                         ELM_SYNDROME_FRGMT_0 - For syndrome fragment 0.\n
 521 *                         ELM_SYNDROME_FRGMT_1 - For syndrome fragment 1.\n
 522 *                         ELM_SYNDROME_FRGMT_2 - For syndrome fragment 2.\n
 523 *                         ELM_SYNDROME_FRGMT_3 - For syndrome fragment 3.\n
 524 *                         ELM_SYNDROME_FRGMT_4 - For syndrome fragment 4.\n
 525 *                         ELM_SYNDROME_FRGMT_5 - For syndrome fragment 5.\n
 526 *                         ELM_SYNDROME_FRGMT_6 - For syndrome fragment 6.\n
 527 * \param   synFrgmtVal    Syndrome fragment value.\n
 528 *
 529 * \param   csNum          Chip Select Number, 0 - 7.\n
 530 *
 531 * \return  None. \n
 532 *
 533 */
 534 void elmSyndromeFrgmtSet(elmHandle hElm, Uint32 synFrgmtId,
 535                          Uint32 synFrgmtVal, Uint32 csNum);
 536
 537 /**
 538 * \brief   This function starts the error-location processing for the polynomial
 539 *          set in the syndrome fragment registers.\n
 540 *
 541 * \param   hElm       ELM handle for accessing HW registers.\n
 542 *
 543 * \param   csNum      Chip Select Number, 0 - 7.\n
 544 *
 545 * \return  None. \n
 546 *
 547 */
 548 void elmErrLocProcessingStart(elmHandle hElm, Uint32 csNum);
 549
 550 /**
 551 * \brief   This function gets the error-location processing status.\n
 552 *
 553 * \param   hElm       ELM handle for accessing HW registers.\n
 554 *
 555 * \param   csNum      Chip Select Number, 0 - 7.\n
 556 *
 557 * \return  status. \n
 558 *          0 : ECC error-location process failed.\n
 559 *          1 : ECC error-location process passed.\n
 560 *
 561 */
 562 Uint32 elmErrLocProcessingStatusGet(elmHandle hElm, Uint32 csNum);
 563
 564 /**
 565 * \brief   This function gets the number of errors detected and located
 566 *          during error-location processing.\n
 567 *
 568 * \param   hElm       ELM handle for accessing HW registers.\n
 569 *
 570 * \param   csNum      Chip Select Number, 0 - 7.\n
 571 *
 572 * \return  Number of errors detected and located.\n
 573 *
 574 */
 575 Uint32 elmNumOfErrsGet(elmHandle hElm, Uint32 csNum);
 576
 577 /**
 578 * \brief   This function gets the Error-location bit address for the error
 579 *          number passed.\n
 580 *
 581 * \param   hElm           ELM handle for accessing HW registers.\n
 582 *
 583 * \param   errNum         Error number.\n
 584 *                         This can take one of the following values :\n
 585 *                         ELM_ERROR_NUM_0 - For 0th error.\n
 586 *                         ELM_ERROR_NUM_1 - For 1th error.\n
 587 *                         ELM_ERROR_NUM_2 - For 2th error.\n
 588 *                         ELM_ERROR_NUM_3 - For 3th error.\n
 589 *                         ELM_ERROR_NUM_4 - For 4th error.\n
 590 *                         ELM_ERROR_NUM_5 - For 5th error.\n
 591 *                         ELM_ERROR_NUM_6 - For 6th error.\n
 592 *                         ELM_ERROR_NUM_7 - For 7th error.\n
 593 *                         ELM_ERROR_NUM_8 - For 8th error.\n
 594 *                         ELM_ERROR_NUM_9 - For 9th error.\n
 595 *                         ELM_ERROR_NUM_10 - For 10th error.\n
 596 *                         ELM_ERROR_NUM_11 - For 11th error.\n
 597 *                         ELM_ERROR_NUM_12 - For 12th error.\n
 598 *                         ELM_ERROR_NUM_13 - For 13th error.\n
 599 *                         ELM_ERROR_NUM_14 - For 14th error.\n
 600 *                         ELM_ERROR_NUM_15 - For 15th error.\n
 601 *
 602 * \param   csNum      Chip Select Number, 0 - 7.\n
 603 *
 604 * \return  Bit address for the error number.\n
 605 *
 606 */
 607 Uint32 elmErrLocBitAddrGet(elmHandle hElm, Uint32 errNum, Uint32 csNum);
 608
 609 #endif // _EVMK2G_ELM_H_