target/linux/generic-2.6/files/crypto/ocf/kirkwood/mvHal/kw_family/ctrlEnv/sys/mvSysPex.c

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12 ********************************************************************************
  13 Marvell Commercial License Option
  14
  15 If you received this File from Marvell and you have entered into a commercial
  16 license agreement (a "Commercial License") with Marvell, the File is licensed
  17 to you under the terms of the applicable Commercial License.
  18
  19 ********************************************************************************
  20 Marvell GPL License Option
  21
  22 If you received this File from Marvell, you may opt to use, redistribute and/or
  23 modify this File in accordance with the terms and conditions of the General
  24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  25 available along with the File in the license.txt file or by writing to the Free
  26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  28
  29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  31 DISCLAIMED.  The GPL License provides additional details about this warranty
  32 disclaimer.
  33 ********************************************************************************
  34 Marvell BSD License Option
  35
  36 If you received this File from Marvell, you may opt to use, redistribute and/or
  37 modify this File under the following licensing terms.
  38 Redistribution and use in source and binary forms, with or without modification,
  39 are permitted provided that the following conditions are met:
  40
  41     *   Redistributions of source code must retain the above copyright notice,
  42             this list of conditions and the following disclaimer.
  43
  44     *   Redistributions in binary form must reproduce the above copyright
  45         notice, this list of conditions and the following disclaimer in the
  46         documentation and/or other materials provided with the distribution.
  47
  48     *   Neither the name of Marvell nor the names of its contributors may be
  49         used to endorse or promote products derived from this software without
  50         specific prior written permission.
  51
  52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62
  63 *******************************************************************************/
  64
  65 #include "ctrlEnv/sys/mvSysPex.h"
  66
  67 /* this structure describes the mapping between a Pex Window and a CPU target*/
  68 typedef struct _pexWinToTarget
  69 {
  70         MV_TARGET target;
  71         MV_BOOL   enable;
  72
  73 }PEX_WIN_TO_TARGET;
  74
  75 /* this array is a priority array that define How Pex windows should be
  76 configured , We have only 6 Pex Windows that can be configured , but we
  77 have maximum of 9 CPU target windows ! the following array is a priority
  78 array where the lowest index has the highest priotiy and the highest
  79 index has the lowest priority of being cnfigured */
  80
  81 MV_U32  pexDevBarPrioTable[] =
  82 {
  83 #if defined(MV_INCLUDE_DEVICE_CS0)
  84     DEVICE_CS0,
  85 #endif
  86 #if defined(MV_INCLUDE_DEVICE_CS1)
  87     DEVICE_CS1,
  88 #endif
  89 #if defined(MV_INCLUDE_DEVICE_CS2)
  90     DEVICE_CS2,
  91 #endif
  92 #if defined(MV_INCLUDE_DEVICE_CS3)
  93     DEVICE_CS3,
  94 #endif
  95 /*
  96 #if defined(MV_INCLUDE_DEVICE_CS4)
  97     DEVICE_CS4,
  98 #endif
  99 */
 100     TBL_TERM
 101 };
 102
 103
 104 /* PEX Wins registers offsets are inconsecutive. This struct describes WIN      */
 105 /* register offsets     and its function where its is located.                                  */
 106 /* Also, PEX address remap registers offsets are inconsecutive. This struct     */
 107 /* describes address remap register offsets                                                                     */
 108 typedef struct _pexWinRegInfo
 109 {
 110     MV_U32 baseLowRegOffs;
 111         MV_U32 baseHighRegOffs;
 112         MV_U32 sizeRegOffs;
 113         MV_U32 remapLowRegOffs;
 114         MV_U32 remapHighRegOffs;
 115
 116 }PEX_WIN_REG_INFO;
 117
 118 static MV_STATUS pexWinOverlapDetect(MV_U32 pexIf, MV_U32 winNum,
 119                                                                          MV_ADDR_WIN *pAddrWin);
 120 static MV_STATUS pexWinRegInfoGet(MV_U32 pexIf, MV_U32 winNum,
 121                                                                   PEX_WIN_REG_INFO *pWinRegInfo);
 122
 123 static MV_STATUS pexBarIsValid(MV_U32 baseLow, MV_U32 size);
 124
 125 static MV_BOOL pexIsWinWithinBar(MV_U32 pexIf,MV_ADDR_WIN *pAddrWin);
 126 static MV_BOOL pexBarOverlapDetect(MV_U32 pexIf,MV_U32 barNum,
 127                                                                    MV_ADDR_WIN *pAddrWin);
 128 const MV_8* pexBarNameGet( MV_U32 bar );
 129
 130
 131 /*******************************************************************************
 132 * mvPexInit - Initialize PEX interfaces
 133 *
 134 * DESCRIPTION:
 135 *
 136 * This function is responsible of intialization of the Pex Interface , It
 137 * configure the Pex Bars and Windows in the following manner:
 138 *
 139 *  Assumptions :
 140 *                               Bar0 is always internal registers bar
 141 *                           Bar1 is always the DRAM bar
 142 *                               Bar2 is always the Device bar
 143 *
 144 *  1) Sets the Internal registers bar base by obtaining the base from
 145 *         the CPU Interface
 146 *  2) Sets the DRAM bar base and size by getting the base and size from
 147 *     the CPU Interface when the size is the sum of all enabled DRAM
 148 *         chip selects and the base is the base of CS0 .
 149 *  3) Sets the Device bar base and size by getting these values from the
 150 *     CPU Interface when the base is the base of the lowest base of the
 151 *     Device chip selects, and the
 152 *
 153 *
 154 * INPUT:
 155 *
 156 *       pexIf   -  PEX interface number.
 157 *
 158 *
 159 * OUTPUT:
 160 *       None.
 161 *
 162 * RETURN:
 163 *       MV_OK if function success otherwise MV_ERROR or MV_BAD_PARAM
 164 *
 165 *******************************************************************************/
 166 MV_STATUS mvPexInit(MV_U32 pexIf, MV_PEX_TYPE pexType)
 167 {
 168         MV_U32                  bar;
 169         MV_U32                  winNum;
 170         MV_PEX_BAR              pexBar;
 171         MV_PEX_DEC_WIN          pexWin;
 172         MV_CPU_DEC_WIN          addrDecWin;
 173         MV_TARGET               target;
 174         MV_U32                  pexCurrWin=0;
 175         MV_U32                  status;
 176         /* default and exapntion rom
 177         are always configured */
 178
 179 #ifndef MV_DISABLE_PEX_DEVICE_BAR
 180         MV_U32                  winIndex;
 181         MV_U32                  maxBase=0, sizeOfMaxBase=0;
 182         MV_U32                  pexStartWindow;
 183 #endif
 184
 185         /* Parameter checking   */
 186         if(pexIf >= mvCtrlPexMaxIfGet())
 187         {
 188                 mvOsPrintf("mvPexInit: ERR. Invalid PEX interface %d\n", pexIf);
 189                 return MV_BAD_PARAM;
 190         }
 191
 192         /* Enabled CPU access to PCI-Express */
 193         mvCpuIfEnablePex(pexIf, pexType);
 194
 195     /* Start with bars */
 196         /* First disable all PEX bars*/
 197         for (bar = 0; bar < PEX_MAX_BARS; bar++)
 198     {
 199                 if (PEX_INTER_REGS_BAR != bar)
 200                 {
 201                         if (MV_OK != mvPexBarEnable(pexIf, bar, MV_FALSE))
 202                         {
 203                                 mvOsPrintf("mvPexInit:mvPexBarEnable bar =%d failed \n",bar);
 204                                 return MV_ERROR;
 205                         }
 206
 207                 }
 208
 209         }
 210
 211         /* and disable all PEX target windows  */
 212         for (winNum = 0; winNum < PEX_MAX_TARGET_WIN - 2; winNum++)
 213     {
 214                 if (MV_OK != mvPexTargetWinEnable(pexIf, winNum, MV_FALSE))
 215                 {
 216                         mvOsPrintf("mvPexInit:mvPexTargetWinEnable winNum =%d failed \n",
 217                                            winNum);
 218                         return MV_ERROR;
 219
 220                 }
 221         }
 222
 223         /* Now, go through all bars*/
 224
 225
 226
 227 /******************************************************************************/
 228 /*                       Internal registers bar                               */
 229 /******************************************************************************/
 230         bar = PEX_INTER_REGS_BAR;
 231
 232         /* we only open the bar , no need to open windows for this bar */
 233
 234         /* first get the CS attribute from the CPU Interface */
 235         if (MV_OK !=mvCpuIfTargetWinGet(INTER_REGS,&addrDecWin))
 236         {
 237                 mvOsPrintf("mvPexInit: ERR. mvCpuIfTargetWinGet failed target =%d\n",INTER_REGS);
 238                 return MV_ERROR;
 239         }
 240
 241         pexBar.addrWin.baseHigh = addrDecWin.addrWin.baseHigh;
 242         pexBar.addrWin.baseLow = addrDecWin.addrWin.baseLow;
 243         pexBar.addrWin.size = addrDecWin.addrWin.size;
 244         pexBar.enable = MV_TRUE;
 245
 246         if (MV_OK != mvPexBarSet(pexIf, bar, &pexBar))
 247         {
 248                 mvOsPrintf("mvPexInit: ERR. mvPexBarSet %d failed\n", bar);
 249                 return MV_ERROR;
 250         }
 251
 252 /******************************************************************************/
 253 /*                                DRAM bar                                    */
 254 /******************************************************************************/
 255
 256         bar = PEX_DRAM_BAR;
 257
 258         pexBar.addrWin.size = 0;
 259
 260         for (target = SDRAM_CS0;target < MV_DRAM_MAX_CS; target++ )
 261         {
 262
 263                 status = mvCpuIfTargetWinGet(target,&addrDecWin);
 264
 265                 if((MV_NO_SUCH == status)&&(target != SDRAM_CS0))
 266                 {
 267                         continue;
 268                 }
 269
 270                 /* first get attributes from CPU If */
 271                 if (MV_OK != status)
 272                 {
 273                         mvOsPrintf("mvPexInit: ERR. mvCpuIfTargetWinGet failed target =%d\n",target);
 274                         return MV_ERROR;
 275                 }
 276                 if (addrDecWin.enable == MV_TRUE)
 277                 {
 278                         /* the base is the base of DRAM CS0 always */
 279                         if (SDRAM_CS0 == target )
 280                         {
 281                                 pexBar.addrWin.baseHigh = addrDecWin.addrWin.baseHigh;
 282                                 pexBar.addrWin.baseLow = addrDecWin.addrWin.baseLow;
 283
 284                         }
 285
 286                         /* increment the bar size to be the sum of the size of all
 287                         DRAM chips selecs */
 288                         pexBar.addrWin.size += addrDecWin.addrWin.size;
 289
 290                         /* set a Pex window for this target !
 291                         DRAM CS always will have a Pex Window , and is not a
 292                         part of the priority table */
 293                         pexWin.addrWin.baseHigh = addrDecWin.addrWin.baseHigh;
 294                         pexWin.addrWin.baseLow = addrDecWin.addrWin.baseLow;
 295                         pexWin.addrWin.size = addrDecWin.addrWin.size;
 296
 297                         /* we disable the windows at first because we are not
 298                         sure that it is witihin bar boundries */
 299                         pexWin.enable =MV_FALSE;
 300                         pexWin.target = target;
 301                         pexWin.targetBar = bar;
 302
 303                         if (MV_OK != mvPexTargetWinSet(pexIf,pexCurrWin++,&pexWin))
 304                         {
 305                                 mvOsPrintf("mvPexInit: ERR. mvPexTargetWinSet failed\n");
 306                                 return MV_ERROR;
 307                         }
 308                 }
 309         }
 310
 311         /* check if the size of the bar is illeggal */
 312         if (-1 == ctrlSizeToReg(pexBar.addrWin.size, PXBCR_BAR_SIZE_ALIGNMENT))
 313         {
 314                 /* try to get a good size */
 315                 pexBar.addrWin.size = ctrlSizeRegRoundUp(pexBar.addrWin.size,
 316                                                                                                  PXBCR_BAR_SIZE_ALIGNMENT);
 317         }
 318
 319         /* check if the size and base are valid */
 320         if (MV_TRUE == pexBarOverlapDetect(pexIf,bar,&pexBar.addrWin))
 321         {
 322                 mvOsPrintf("mvPexInit:Warning :Bar %d size is illigal\n",bar);
 323                 mvOsPrintf("it will be disabled\n");
 324                 mvOsPrintf("please check Pex and CPU windows configuration\n");
 325         }
 326         else
 327         {
 328                 pexBar.enable = MV_TRUE;
 329
 330                 /* configure the bar */
 331                 if (MV_OK != mvPexBarSet(pexIf, bar, &pexBar))
 332                 {
 333                         mvOsPrintf("mvPexInit: ERR. mvPexBarSet %d failed\n", bar);
 334                         return MV_ERROR;
 335                 }
 336
 337                 /* after the bar was configured then we enable the Pex windows*/
 338                 for (winNum = 0;winNum < pexCurrWin ;winNum++)
 339                 {
 340                         if (MV_OK != mvPexTargetWinEnable(pexIf, winNum, MV_TRUE))
 341                         {
 342                                 mvOsPrintf("mvPexInit: Can't enable window =%d\n",winNum);
 343                                 return MV_ERROR;
 344                         }
 345
 346                 }
 347         }
 348
 349 /******************************************************************************/
 350 /*                              DEVICE bar                                    */
 351 /******************************************************************************/
 352
 353 /* Open the Device BAR for non linux only */
 354 #ifndef MV_DISABLE_PEX_DEVICE_BAR
 355
 356         /* then device  bar*/
 357         bar = PEX_DEVICE_BAR;
 358
 359         /* save the starting window */
 360         pexStartWindow = pexCurrWin;
 361         pexBar.addrWin.size = 0;
 362         pexBar.addrWin.baseLow = 0xffffffff;
 363         pexBar.addrWin.baseHigh = 0;
 364         maxBase = 0;
 365
 366         for (target = DEV_TO_TARGET(START_DEV_CS);target < DEV_TO_TARGET(MV_DEV_MAX_CS); target++ )
 367         {
 368                 status = mvCpuIfTargetWinGet(target,&addrDecWin);
 369
 370                 if (MV_NO_SUCH == status)
 371                 {
 372                         continue;
 373                 }
 374
 375                 if (MV_OK != status)
 376                 {
 377                         mvOsPrintf("mvPexInit: ERR. mvCpuIfTargetWinGet failed target =%d\n",target);
 378                         return MV_ERROR;
 379                 }
 380
 381                 if (addrDecWin.enable == MV_TRUE)
 382                 {
 383                         /* get the minimum base */
 384                         if (addrDecWin.addrWin.baseLow < pexBar.addrWin.baseLow)
 385                         {
 386                                 pexBar.addrWin.baseLow = addrDecWin.addrWin.baseLow;
 387                         }
 388
 389                         /* get the maximum base */
 390                         if (addrDecWin.addrWin.baseLow > maxBase)
 391                         {
 392                                 maxBase = addrDecWin.addrWin.baseLow;
 393                                 sizeOfMaxBase = addrDecWin.addrWin.size;
 394                         }
 395
 396                         /* search in the priority table for this target */
 397                         for (winIndex = 0; pexDevBarPrioTable[winIndex] != TBL_TERM;
 398                                  winIndex++)
 399                         {
 400                                 if (pexDevBarPrioTable[winIndex] != target)
 401                                 {
 402                                         continue;
 403                                 }
 404                                 else if (pexDevBarPrioTable[winIndex] == target)
 405                                 {
 406                                         /*found it */
 407
 408                                         /* if the index of this target in the prio table is valid
 409                                         then we set the Pex window for this target, a valid index is
 410                                         an index that is lower than the number of the windows that
 411                                         was not configured yet */
 412
 413                                         /* we subtract 2 always because the default and expantion
 414                                         rom windows are always configured */
 415                                         if ( pexCurrWin  < PEX_MAX_TARGET_WIN - 2)
 416                                         {
 417                                                 /* set a Pex window for this target !  */
 418                                                 pexWin.addrWin.baseHigh = addrDecWin.addrWin.baseHigh;
 419                                                 pexWin.addrWin.baseLow = addrDecWin.addrWin.baseLow;
 420                                                 pexWin.addrWin.size = addrDecWin.addrWin.size;
 421
 422                                                 /* we disable the windows at first because we are not
 423                                                 sure that it is witihin bar boundries */
 424                                                 pexWin.enable = MV_FALSE;
 425                                                 pexWin.target = target;
 426                                                 pexWin.targetBar = bar;
 427
 428                                                 if (MV_OK != mvPexTargetWinSet(pexIf,pexCurrWin++,
 429                                                                                                            &pexWin))
 430                                                 {
 431                                                         mvOsPrintf("mvPexInit: ERR. Window Set failed\n");
 432                                                         return MV_ERROR;
 433                                                 }
 434                                         }
 435                                 }
 436                         }
 437                 }
 438         }
 439
 440         pexBar.addrWin.size = maxBase - pexBar.addrWin.baseLow + sizeOfMaxBase;
 441         pexBar.enable = MV_TRUE;
 442
 443         /* check if the size of the bar is illegal */
 444         if (-1 == ctrlSizeToReg(pexBar.addrWin.size, PXBCR_BAR_SIZE_ALIGNMENT))
 445         {
 446                 /* try to get a good size */
 447                 pexBar.addrWin.size = ctrlSizeRegRoundUp(pexBar.addrWin.size,
 448                                                                                                  PXBCR_BAR_SIZE_ALIGNMENT);
 449         }
 450
 451         /* check if the size and base are valid */
 452         if (MV_TRUE == pexBarOverlapDetect(pexIf,bar,&pexBar.addrWin))
 453         {
 454                 mvOsPrintf("mvPexInit:Warning :Bar %d size is illigal\n",bar);
 455                 mvOsPrintf("it will be disabled\n");
 456                 mvOsPrintf("please check Pex and CPU windows configuration\n");
 457         }
 458         else
 459         {
 460                 if (MV_OK != mvPexBarSet(pexIf, bar, &pexBar))
 461                 {
 462                         mvOsPrintf("mvPexInit: ERR. mvPexBarSet %d failed\n", bar);
 463                         return MV_ERROR;
 464                 }
 465
 466                 /* now enable the windows */
 467                 for (winNum = pexStartWindow; winNum < pexCurrWin ; winNum++)
 468                 {
 469                         if (MV_OK != mvPexTargetWinEnable(pexIf, winNum, MV_TRUE))
 470                         {
 471                                 mvOsPrintf("mvPexInit:mvPexTargetWinEnable winNum =%d failed \n",
 472                                                    winNum);
 473                                 return MV_ERROR;
 474                         }
 475                 }
 476         }
 477
 478 #endif
 479
 480         return mvPexHalInit(pexIf, pexType);
 481
 482 }
 483
 484 /*******************************************************************************
 485 * mvPexTargetWinSet - Set PEX to peripheral target address window BAR
 486 *
 487 * DESCRIPTION:
 488 *
 489 * INPUT:
 490 *
 491 * OUTPUT:
 492 *       N/A
 493 *
 494 * RETURN:
 495 *       MV_OK if PEX BAR target window was set correctly,
 496 *               MV_BAD_PARAM on bad params
 497 *       MV_ERROR otherwise
 498 *       (e.g. address window overlapps with other active PEX target window).
 499 *
 500 *******************************************************************************/
 501 MV_STATUS mvPexTargetWinSet(MV_U32 pexIf, MV_U32 winNum,
 502                             MV_PEX_DEC_WIN *pAddrDecWin)
 503 {
 504
 505         MV_DEC_REGS decRegs;
 506         PEX_WIN_REG_INFO winRegInfo;
 507         MV_TARGET_ATTRIB targetAttribs;
 508
 509         /* Parameter checking   */
 510         if(pexIf >= mvCtrlPexMaxIfGet())
 511         {
 512                 mvOsPrintf("mvPexTargetWinSet: ERR. Invalid PEX interface %d\n", pexIf);
 513                 return MV_BAD_PARAM;
 514         }
 515
 516         if (winNum >= PEX_MAX_TARGET_WIN)
 517         {
 518                 mvOsPrintf("mvPexTargetWinSet: ERR. Invalid PEX winNum %d\n", winNum);
 519                 return MV_BAD_PARAM;
 520
 521         }
 522
 523         /* get the pex Window registers offsets */
 524         pexWinRegInfoGet(pexIf,winNum,&winRegInfo);
 525
 526
 527         if (MV_TRUE == pAddrDecWin->enable)
 528         {
 529
 530                 /* 2) Check if the requested window overlaps with current windows  */
 531                 if (MV_TRUE == pexWinOverlapDetect(pexIf,winNum, &pAddrDecWin->addrWin))
 532                 {
 533                         mvOsPrintf("mvPexTargetWinSet: ERR. Target %d overlap\n", winNum);
 534                         return MV_BAD_PARAM;
 535                 }
 536
 537                 /* 2) Check if the requested window overlaps with current windows  */
 538                 if (MV_FALSE == pexIsWinWithinBar(pexIf,&pAddrDecWin->addrWin))
 539                 {
 540                         mvOsPrintf("mvPexTargetWinSet: Win %d should be in bar boundries\n",
 541                                            winNum);
 542                         return MV_BAD_PARAM;
 543                 }
 544
 545         }
 546
 547
 548
 549         /* read base register*/
 550
 551         if (winRegInfo.baseLowRegOffs)
 552         {
 553                 decRegs.baseReg = MV_REG_READ(winRegInfo.baseLowRegOffs);
 554         }
 555         else
 556         {
 557                 decRegs.baseReg = 0;
 558         }
 559
 560         if (winRegInfo.sizeRegOffs)
 561         {
 562                 decRegs.sizeReg = MV_REG_READ(winRegInfo.sizeRegOffs);
 563         }
 564         else
 565         {
 566                 decRegs.sizeReg =0;
 567         }
 568
 569         if (MV_OK != mvCtrlAddrDecToReg(&(pAddrDecWin->addrWin),&decRegs))
 570         {
 571                 mvOsPrintf("mvPexTargetWinSet:mvCtrlAddrDecToReg Failed\n");
 572                 return MV_ERROR;
 573         }
 574
 575         /* enable\Disable */
 576         if (MV_TRUE == pAddrDecWin->enable)
 577         {
 578                 decRegs.sizeReg |= PXWCR_WIN_EN;
 579         }
 580         else
 581         {
 582                 decRegs.sizeReg &= ~PXWCR_WIN_EN;
 583         }
 584
 585
 586         /* clear bit location */
 587         decRegs.sizeReg &= ~PXWCR_WIN_BAR_MAP_MASK;
 588
 589         /* set bar Mapping */
 590         if (pAddrDecWin->targetBar == 1)
 591         {
 592                 decRegs.sizeReg |= PXWCR_WIN_BAR_MAP_BAR1;
 593         }
 594         else if (pAddrDecWin->targetBar == 2)
 595         {
 596                 decRegs.sizeReg |= PXWCR_WIN_BAR_MAP_BAR2;
 597         }
 598
 599         mvCtrlAttribGet(pAddrDecWin->target,&targetAttribs);
 600
 601         /* set attributes */
 602         decRegs.sizeReg &= ~PXWCR_ATTRIB_MASK;
 603         decRegs.sizeReg |= targetAttribs.attrib << PXWCR_ATTRIB_OFFS;
 604         /* set target ID */
 605         decRegs.sizeReg &= ~PXWCR_TARGET_MASK;
 606         decRegs.sizeReg |= targetAttribs.targetId << PXWCR_TARGET_OFFS;
 607
 608
 609         /* 3) Write to address decode Base Address Register                   */
 610
 611         if (winRegInfo.baseLowRegOffs)
 612         {
 613                 MV_REG_WRITE(winRegInfo.baseLowRegOffs, decRegs.baseReg);
 614         }
 615
 616         /* write size reg */
 617         if (winRegInfo.sizeRegOffs)
 618         {
 619                 if ((MV_PEX_WIN_DEFAULT == winNum)||
 620                         (MV_PEX_WIN_EXP_ROM == winNum))
 621                 {
 622                         /* clear size because there is no size field*/
 623                         decRegs.sizeReg &= ~PXWCR_SIZE_MASK;
 624
 625                         /* clear enable because there is no enable field*/
 626                         decRegs.sizeReg &= ~PXWCR_WIN_EN;
 627
 628                 }
 629
 630                 MV_REG_WRITE(winRegInfo.sizeRegOffs, decRegs.sizeReg);
 631         }
 632
 633
 634     return MV_OK;
 635
 636 }
 637
 638 /*******************************************************************************
 639 * mvPexTargetWinGet - Get PEX to peripheral target address window
 640 *
 641 * DESCRIPTION:
 642 *               Get the PEX to peripheral target address window BAR.
 643 *
 644 * INPUT:
 645 *       pexIf - PEX interface number.
 646 *       bar   - BAR to be accessed by slave.
 647 *
 648 * OUTPUT:
 649 *       pAddrBarWin - PEX target window information data structure.
 650 *
 651 * RETURN:
 652 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 653 *
 654 *******************************************************************************/
 655 MV_STATUS mvPexTargetWinGet(MV_U32 pexIf, MV_U32 winNum,
 656                             MV_PEX_DEC_WIN *pAddrDecWin)
 657 {
 658         MV_TARGET_ATTRIB targetAttrib;
 659         MV_DEC_REGS decRegs;
 660
 661         PEX_WIN_REG_INFO winRegInfo;
 662
 663         /* Parameter checking   */
 664         if(pexIf >= mvCtrlPexMaxIfGet())
 665         {
 666                 mvOsPrintf("mvPexTargetWinGet: ERR. Invalid PEX interface %d\n", pexIf);
 667                 return MV_BAD_PARAM;
 668         }
 669
 670         if (winNum >= PEX_MAX_TARGET_WIN)
 671         {
 672                 mvOsPrintf("mvPexTargetWinGet: ERR. Invalid PEX winNum %d\n", winNum);
 673                 return MV_BAD_PARAM;
 674
 675         }
 676
 677         /* get the pex Window registers offsets */
 678         pexWinRegInfoGet(pexIf,winNum,&winRegInfo);
 679
 680         /* read base register*/
 681         if (winRegInfo.baseLowRegOffs)
 682         {
 683                 decRegs.baseReg = MV_REG_READ(winRegInfo.baseLowRegOffs);
 684         }
 685         else
 686         {
 687                 decRegs.baseReg = 0;
 688         }
 689
 690         /* read size reg */
 691         if (winRegInfo.sizeRegOffs)
 692         {
 693                 decRegs.sizeReg = MV_REG_READ(winRegInfo.sizeRegOffs);
 694         }
 695         else
 696         {
 697                 decRegs.sizeReg =0;
 698         }
 699
 700         if (MV_OK != mvCtrlRegToAddrDec(&decRegs,&(pAddrDecWin->addrWin)))
 701         {
 702                 mvOsPrintf("mvPexTargetWinGet: mvCtrlRegToAddrDec Failed \n");
 703                 return MV_ERROR;
 704
 705         }
 706
 707         if (decRegs.sizeReg & PXWCR_WIN_EN)
 708         {
 709                 pAddrDecWin->enable = MV_TRUE;
 710         }
 711         else
 712         {
 713                 pAddrDecWin->enable = MV_FALSE;
 714
 715         }
 716
 717
 718         #if 0
 719     if (-1 == pAddrDecWin->addrWin.size)
 720         {
 721                 return MV_ERROR;
 722         }
 723         #endif
 724
 725
 726         /* get target bar */
 727         if ((decRegs.sizeReg & PXWCR_WIN_BAR_MAP_MASK) == PXWCR_WIN_BAR_MAP_BAR1 )
 728         {
 729                 pAddrDecWin->targetBar = 1;
 730         }
 731         else if ((decRegs.sizeReg & PXWCR_WIN_BAR_MAP_MASK) ==
 732                          PXWCR_WIN_BAR_MAP_BAR2 )
 733         {
 734                 pAddrDecWin->targetBar = 2;
 735         }
 736
 737         /* attrib and targetId */
 738         pAddrDecWin->attrib = (decRegs.sizeReg & PXWCR_ATTRIB_MASK) >>
 739                                                                                                         PXWCR_ATTRIB_OFFS;
 740         pAddrDecWin->targetId = (decRegs.sizeReg & PXWCR_TARGET_MASK) >>
 741                                                                                                         PXWCR_TARGET_OFFS;
 742
 743         targetAttrib.attrib = pAddrDecWin->attrib;
 744         targetAttrib.targetId = pAddrDecWin->targetId;
 745
 746         pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
 747
 748         return MV_OK;
 749
 750 }
 751
 752
 753 /*******************************************************************************
 754 * mvPexTargetWinEnable - Enable/disable a PEX BAR window
 755 *
 756 * DESCRIPTION:
 757 *       This function enable/disable a PEX BAR window.
 758 *       if parameter 'enable' == MV_TRUE the routine will enable the
 759 *       window, thus enabling PEX accesses for that BAR (before enabling the
 760 *       window it is tested for overlapping). Otherwise, the window will
 761 *       be disabled.
 762 *
 763 * INPUT:
 764 *       pexIf  - PEX interface number.
 765 *       bar    - BAR to be accessed by slave.
 766 *       enable - Enable/disable parameter.
 767 *
 768 * OUTPUT:
 769 *       None.
 770 *
 771 * RETURN:
 772 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 773 *
 774 *******************************************************************************/
 775 MV_STATUS mvPexTargetWinEnable(MV_U32 pexIf,MV_U32 winNum, MV_BOOL enable)
 776 {
 777         PEX_WIN_REG_INFO winRegInfo;
 778         MV_PEX_DEC_WIN addrDecWin;
 779
 780         /* Parameter checking   */
 781         if(pexIf >= mvCtrlPexMaxIfGet())
 782         {
 783                 mvOsPrintf("mvPexTargetWinEnable: ERR. Invalid PEX If %d\n", pexIf);
 784                 return MV_BAD_PARAM;
 785         }
 786
 787         if (winNum >= PEX_MAX_TARGET_WIN)
 788         {
 789                 mvOsPrintf("mvPexTargetWinEnable ERR. Invalid PEX winNum %d\n", winNum);
 790                 return MV_BAD_PARAM;
 791
 792         }
 793
 794
 795         /* get the pex Window registers offsets */
 796         pexWinRegInfoGet(pexIf,winNum,&winRegInfo);
 797
 798
 799         /* if the address windows is disabled , we only disable the appropriare
 800         pex window and ignore other settings */
 801
 802         if (MV_FALSE == enable)
 803         {
 804
 805                 /* this is not relevant to default and expantion rom
 806                 windows */
 807                 if (winRegInfo.sizeRegOffs)
 808                 {
 809                         if ((MV_PEX_WIN_DEFAULT != winNum)&&
 810                                 (MV_PEX_WIN_EXP_ROM != winNum))
 811                         {
 812                                 MV_REG_BIT_RESET(winRegInfo.sizeRegOffs, PXWCR_WIN_EN);
 813                         }
 814                 }
 815
 816         }
 817         else
 818         {
 819                 if (MV_OK != mvPexTargetWinGet(pexIf,winNum, &addrDecWin))
 820                 {
 821                         mvOsPrintf("mvPexTargetWinEnable: mvPexTargetWinGet Failed\n");
 822                         return MV_ERROR;
 823                 }
 824
 825                 /* Check if the requested window overlaps with current windows  */
 826                 if (MV_TRUE == pexWinOverlapDetect(pexIf,winNum, &addrDecWin.addrWin))
 827                 {
 828                         mvOsPrintf("mvPexTargetWinEnable: ERR. Target %d overlap\n", winNum);
 829                         return MV_BAD_PARAM;
 830                 }
 831
 832                 if (MV_FALSE == pexIsWinWithinBar(pexIf,&addrDecWin.addrWin))
 833                 {
 834                         mvOsPrintf("mvPexTargetWinEnable: Win %d should be in bar boundries\n",
 835                                            winNum);
 836                         return MV_BAD_PARAM;
 837                 }
 838
 839
 840                 /* this is not relevant to default and expantion rom
 841                 windows */
 842                 if (winRegInfo.sizeRegOffs)
 843                 {
 844                         if ((MV_PEX_WIN_DEFAULT != winNum)&&
 845                                 (MV_PEX_WIN_EXP_ROM != winNum))
 846                         {
 847                                 MV_REG_BIT_SET(winRegInfo.sizeRegOffs, PXWCR_WIN_EN);
 848                         }
 849                 }
 850
 851
 852         }
 853
 854         return MV_OK;
 855
 856 }
 857
 858
 859
 860 /*******************************************************************************
 861 * mvPexTargetWinRemap - Set PEX to target address window remap.
 862 *
 863 * DESCRIPTION:
 864 *       The PEX interface supports remap of the BAR original address window.
 865 *       For each BAR it is possible to define a remap address. For example
 866 *       an address 0x12345678 that hits BAR 0x10 (SDRAM CS[0]) will be modified
 867 *       according to remap register but will also be targeted to the
 868 *       SDRAM CS[0].
 869 *
 870 * INPUT:
 871 *       pexIf    - PEX interface number.
 872 *       bar      - Peripheral target enumerator accessed by slave.
 873 *       pAddrWin - Address window to be checked.
 874 *
 875 * OUTPUT:
 876 *       None.
 877 *
 878 * RETURN:
 879 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 880 *
 881 *******************************************************************************/
 882 MV_STATUS mvPexTargetWinRemap(MV_U32 pexIf, MV_U32 winNum,
 883                            MV_PEX_REMAP_WIN *pAddrWin)
 884 {
 885
 886         PEX_WIN_REG_INFO winRegInfo;
 887
 888         /* Parameter checking   */
 889         if (pexIf >= mvCtrlPexMaxIfGet())
 890         {
 891                 mvOsPrintf("mvPexTargetWinRemap: ERR. Invalid PEX interface num %d\n",
 892                                                                                                                                                 pexIf);
 893                 return MV_BAD_PARAM;
 894         }
 895         if (MV_PEX_WIN_DEFAULT == winNum)
 896         {
 897                 mvOsPrintf("mvPexTargetWinRemap: ERR. Invalid PEX win num %d\n",
 898                                                                                                                                                 winNum);
 899                 return MV_BAD_PARAM;
 900
 901         }
 902
 903         if (MV_IS_NOT_ALIGN(pAddrWin->addrWin.baseLow, PXWRR_REMAP_ALIGNMENT))
 904         {
 905                 mvOsPrintf("mvPexTargetWinRemap: Error remap PEX interface %d win %d."\
 906                                    "\nAddress 0x%08x is unaligned to size 0x%x.\n",
 907                                    pexIf,
 908                                    winNum,
 909                    pAddrWin->addrWin.baseLow,
 910                                    pAddrWin->addrWin.size);
 911
 912                 return MV_ERROR;
 913         }
 914
 915         pexWinRegInfoGet(pexIf, winNum, &winRegInfo);
 916
 917         /* Set remap low register value */
 918         MV_REG_WRITE(winRegInfo.remapLowRegOffs, pAddrWin->addrWin.baseLow);
 919
 920         /* Skip base high settings if the BAR has only base low (32-bit)                */
 921         if (0 != winRegInfo.remapHighRegOffs)
 922         {
 923                 MV_REG_WRITE(winRegInfo.remapHighRegOffs, pAddrWin->addrWin.baseHigh);
 924         }
 925
 926
 927         if (pAddrWin->enable == MV_TRUE)
 928         {
 929                 MV_REG_BIT_SET(winRegInfo.remapLowRegOffs,PXWRR_REMAP_EN);
 930         }
 931         else
 932         {
 933                 MV_REG_BIT_RESET(winRegInfo.remapLowRegOffs,PXWRR_REMAP_EN);
 934         }
 935
 936         return MV_OK;
 937 }
 938
 939 /*******************************************************************************
 940 * mvPexTargetWinRemapEnable -
 941 *
 942 * DESCRIPTION:
 943 *
 944 * INPUT:
 945 *
 946 * OUTPUT:
 947 *
 948 * RETURN:
 949 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 950 *
 951 *******************************************************************************/
 952
 953 MV_STATUS mvPexTargetWinRemapEnable(MV_U32 pexIf, MV_U32 winNum,
 954                            MV_BOOL enable)
 955 {
 956         PEX_WIN_REG_INFO winRegInfo;
 957
 958         /* Parameter checking   */
 959         if (pexIf >= mvCtrlPexMaxIfGet())
 960         {
 961                 mvOsPrintf("mvPexTargetWinRemap: ERR. Invalid PEX interface num %d\n",
 962                                                                                                                                                 pexIf);
 963                 return MV_BAD_PARAM;
 964         }
 965         if (MV_PEX_WIN_DEFAULT == winNum)
 966         {
 967                 mvOsPrintf("mvPexTargetWinRemap: ERR. Invalid PEX win num %d\n",
 968                                                                                                                                                 winNum);
 969                 return MV_BAD_PARAM;
 970
 971         }
 972
 973
 974         pexWinRegInfoGet(pexIf, winNum, &winRegInfo);
 975
 976         if (enable == MV_TRUE)
 977         {
 978                 MV_REG_BIT_SET(winRegInfo.remapLowRegOffs,PXWRR_REMAP_EN);
 979         }
 980         else
 981         {
 982                 MV_REG_BIT_RESET(winRegInfo.remapLowRegOffs,PXWRR_REMAP_EN);
 983         }
 984
 985         return MV_OK;
 986
 987 }
 988
 989 /*******************************************************************************
 990 *  mvPexBarSet - Set PEX bar address and size
 991 *
 992 * DESCRIPTION:
 993 *
 994 * INPUT:
 995 *
 996 * OUTPUT:
 997 *       None.
 998 *
 999 * RETURN:
1000 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
1001 *
1002 *******************************************************************************/
1003 MV_STATUS mvPexBarSet(MV_U32 pexIf,
1004                                                 MV_U32 barNum,
1005                                                 MV_PEX_BAR *pAddrWin)
1006 {
1007         MV_U32 regBaseLow;
1008         MV_U32 regSize,sizeToReg;
1009
1010
1011         /* check parameters */
1012         if(pexIf >= mvCtrlPexMaxIfGet())
1013         {
1014                 mvOsPrintf("mvPexBarSet: ERR. Invalid PEX interface %d\n", pexIf);
1015                 return MV_BAD_PARAM;
1016         }
1017
1018         if(barNum >= PEX_MAX_BARS)
1019         {
1020                 mvOsPrintf("mvPexBarSet: ERR. Invalid bar number %d\n", barNum);
1021                 return MV_BAD_PARAM;
1022         }
1023
1024
1025         if (pAddrWin->addrWin.size == 0)
1026         {
1027                 mvOsPrintf("mvPexBarSet: Size zero is Illigal\n" );
1028                 return MV_BAD_PARAM;
1029         }
1030
1031
1032         /* Check if the window complies with PEX spec                                                   */
1033         if (MV_TRUE != pexBarIsValid(pAddrWin->addrWin.baseLow,
1034                                                                  pAddrWin->addrWin.size))
1035         {
1036         mvOsPrintf("mvPexBarSet: ERR. Target %d window invalid\n", barNum);
1037                 return MV_BAD_PARAM;
1038         }
1039
1040     /* 2) Check if the requested bar overlaps with current bars         */
1041     if (MV_TRUE == pexBarOverlapDetect(pexIf,barNum, &pAddrWin->addrWin))
1042         {
1043         mvOsPrintf("mvPexBarSet: ERR. Target %d overlap\n", barNum);
1044                 return MV_BAD_PARAM;
1045         }
1046
1047         /* Get size register value according to window size                                             */
1048         sizeToReg = ctrlSizeToReg(pAddrWin->addrWin.size, PXBCR_BAR_SIZE_ALIGNMENT);
1049
1050         /* Read bar size */
1051         if (PEX_INTER_REGS_BAR != barNum) /* internal registers have no size */
1052         {
1053                 regSize = MV_REG_READ(PEX_BAR_CTRL_REG(pexIf,barNum));
1054
1055                 /* Size parameter validity check.                                   */
1056                 if (-1 == sizeToReg)
1057                 {
1058                         mvOsPrintf("mvPexBarSet: ERR. Target BAR %d size invalid.\n",barNum);
1059                         return MV_BAD_PARAM;
1060                 }
1061
1062                 regSize &= ~PXBCR_BAR_SIZE_MASK;
1063                 regSize |= (sizeToReg << PXBCR_BAR_SIZE_OFFS) ;
1064
1065                 MV_REG_WRITE(PEX_BAR_CTRL_REG(pexIf,barNum),regSize);
1066
1067         }
1068
1069         /* set size */
1070
1071
1072
1073         /* Read base address low */
1074         regBaseLow = MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf,
1075                                                                                                    PEX_MV_BAR_BASE(barNum)));
1076
1077         /* clear current base */
1078         if (PEX_INTER_REGS_BAR == barNum)
1079         {
1080                 regBaseLow &= ~PXBIR_BASE_MASK;
1081         regBaseLow |= (pAddrWin->addrWin.baseLow & PXBIR_BASE_MASK);
1082         }
1083         else
1084         {
1085                 regBaseLow &= ~PXBR_BASE_MASK;
1086                 regBaseLow |= (pAddrWin->addrWin.baseLow & PXBR_BASE_MASK);
1087         }
1088
1089         /* if we had a previous value that contain the bar type (MeM\IO), we want to
1090         restore it */
1091         regBaseLow |= PEX_BAR_DEFAULT_ATTRIB;
1092
1093
1094
1095         /* write base low */
1096     MV_REG_WRITE(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_MV_BAR_BASE(barNum)),
1097                                 regBaseLow);
1098
1099         if (pAddrWin->addrWin.baseHigh != 0)
1100         {
1101                 /* Read base address high */
1102                 MV_REG_WRITE(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_MV_BAR_BASE_HIGH(barNum)),
1103                                                                  pAddrWin->addrWin.baseHigh);
1104
1105         }
1106
1107         /* lastly enable the Bar */
1108         if (pAddrWin->enable == MV_TRUE)
1109         {
1110                 if (PEX_INTER_REGS_BAR != barNum) /* internal registers
1111                                                                                                 are enabled always */
1112                 {
1113                         MV_REG_BIT_SET(PEX_BAR_CTRL_REG(pexIf,barNum),PXBCR_BAR_EN);
1114                 }
1115         }
1116         else if (MV_FALSE == pAddrWin->enable)
1117         {
1118                 if (PEX_INTER_REGS_BAR != barNum) /* internal registers
1119                                                                                                 are enabled always */
1120                 {
1121                         MV_REG_BIT_RESET(PEX_BAR_CTRL_REG(pexIf,barNum),PXBCR_BAR_EN);
1122                 }
1123
1124         }
1125
1126
1127
1128         return MV_OK;
1129 }
1130
1131
1132 /*******************************************************************************
1133 *  mvPexBarGet - Get PEX bar address and size
1134 *
1135 * DESCRIPTION:
1136 *
1137 * INPUT:
1138 *
1139 * OUTPUT:
1140 *       None.
1141 *
1142 * RETURN:
1143 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
1144 *
1145 *******************************************************************************/
1146
1147 MV_STATUS mvPexBarGet(MV_U32 pexIf,
1148                                                                 MV_U32 barNum,
1149                                                                 MV_PEX_BAR *pAddrWin)
1150 {
1151         /* check parameters */
1152         if(pexIf >= mvCtrlPexMaxIfGet())
1153         {
1154                 mvOsPrintf("mvPexBarGet: ERR. Invalid PEX interface %d\n", pexIf);
1155                 return MV_BAD_PARAM;
1156         }
1157
1158         if(barNum >= PEX_MAX_BARS)
1159         {
1160                 mvOsPrintf("mvPexBarGet: ERR. Invalid bar number %d\n", barNum);
1161                 return MV_BAD_PARAM;
1162         }
1163
1164         /* read base low */
1165         pAddrWin->addrWin.baseLow =
1166                 MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_MV_BAR_BASE(barNum)));
1167
1168
1169         if (PEX_INTER_REGS_BAR == barNum)
1170         {
1171                 pAddrWin->addrWin.baseLow &= PXBIR_BASE_MASK;
1172         }
1173         else
1174         {
1175                 pAddrWin->addrWin.baseLow &= PXBR_BASE_MASK;
1176         }
1177
1178
1179         /* read base high */
1180         pAddrWin->addrWin.baseHigh =
1181                 MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_MV_BAR_BASE_HIGH(barNum)));
1182
1183
1184         /* Read bar size */
1185         if (PEX_INTER_REGS_BAR != barNum) /* internal registers have no size */
1186         {
1187                 pAddrWin->addrWin.size = MV_REG_READ(PEX_BAR_CTRL_REG(pexIf,barNum));
1188
1189                 /* check if enable or not */
1190                 if (pAddrWin->addrWin.size & PXBCR_BAR_EN)
1191                 {
1192                         pAddrWin->enable = MV_TRUE;
1193                 }
1194                 else
1195                 {
1196                         pAddrWin->enable = MV_FALSE;
1197                 }
1198
1199                 /* now get the size */
1200                 pAddrWin->addrWin.size &= PXBCR_BAR_SIZE_MASK;
1201                 pAddrWin->addrWin.size >>= PXBCR_BAR_SIZE_OFFS;
1202
1203                 pAddrWin->addrWin.size = ctrlRegToSize(pAddrWin->addrWin.size,
1204                                                                                            PXBCR_BAR_SIZE_ALIGNMENT);
1205
1206         }
1207         else /* PEX_INTER_REGS_BAR */
1208         {
1209                 pAddrWin->addrWin.size = INTER_REGS_SIZE;
1210                 pAddrWin->enable = MV_TRUE;
1211         }
1212
1213
1214         return MV_OK;
1215 }
1216
1217 /*******************************************************************************
1218 *  mvPexBarEnable -
1219 *
1220 * DESCRIPTION:
1221 *
1222 * INPUT:
1223 *
1224 * OUTPUT:
1225 *       None.
1226 *
1227 * RETURN:
1228 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
1229 *
1230 *******************************************************************************/
1231
1232
1233 MV_STATUS mvPexBarEnable(MV_U32 pexIf, MV_U32 barNum, MV_BOOL enable)
1234 {
1235
1236         MV_PEX_BAR pexBar;
1237
1238         /* check parameters */
1239         if(pexIf >= mvCtrlPexMaxIfGet())
1240         {
1241                 mvOsPrintf("mvPexBarEnable: ERR. Invalid PEX interface %d\n", pexIf);
1242                 return MV_BAD_PARAM;
1243         }
1244
1245
1246         if(barNum >= PEX_MAX_BARS)
1247         {
1248                 mvOsPrintf("mvPexBarEnable: ERR. Invalid bar number %d\n", barNum);
1249                 return MV_BAD_PARAM;
1250         }
1251
1252     if (PEX_INTER_REGS_BAR == barNum)
1253         {
1254                 if (MV_TRUE == enable)
1255                 {
1256                         return MV_OK;
1257                 }
1258                 else
1259                 {
1260                         return MV_ERROR;
1261                 }
1262         }
1263
1264
1265         if (MV_FALSE == enable)
1266         {
1267                         /* disable bar and quit */
1268                         MV_REG_BIT_RESET(PEX_BAR_CTRL_REG(pexIf,barNum),PXBCR_BAR_EN);
1269                         return MV_OK;
1270         }
1271
1272         /* else */
1273
1274         if (mvPexBarGet(pexIf,barNum,&pexBar) != MV_OK)
1275         {
1276                 mvOsPrintf("mvPexBarEnable: mvPexBarGet Failed\n");
1277                 return MV_ERROR;
1278
1279         }
1280
1281         if (MV_TRUE == pexBar.enable)
1282         {
1283                 /* it is already enabled !!! */
1284                 return MV_OK;
1285         }
1286
1287         /* else enable the bar*/
1288
1289         pexBar.enable = MV_TRUE;
1290
1291         if (mvPexBarSet(pexIf,barNum,&pexBar) != MV_OK)
1292         {
1293                 mvOsPrintf("mvPexBarEnable: mvPexBarSet Failed\n");
1294                 return MV_ERROR;
1295
1296         }
1297
1298         return MV_OK;
1299 }
1300
1301
1302 /*******************************************************************************
1303 * pexWinOverlapDetect - Detect address windows overlapping
1304 *
1305 * DESCRIPTION:
1306 *       This function detects address window overlapping of a given address
1307 *       window in PEX BARs.
1308 *
1309 * INPUT:
1310 *       pAddrWin - Address window to be checked.
1311 *       bar      - BAR to be accessed by slave.
1312 *
1313 * OUTPUT:
1314 *       None.
1315 *
1316 * RETURN:
1317 *       MV_TRUE if the given address window overlap current address
1318 *       decode map, MV_FALSE otherwise.
1319 *
1320 *******************************************************************************/
1321 static MV_BOOL pexWinOverlapDetect(MV_U32 pexIf,
1322                                                                          MV_U32 winNum,
1323                                                                          MV_ADDR_WIN *pAddrWin)
1324 {
1325     MV_U32                 win;
1326         MV_PEX_DEC_WIN addrDecWin;
1327
1328
1329         for(win = 0; win < PEX_MAX_TARGET_WIN -2 ; win++)
1330     {
1331         /* don't check our target or illegal targets */
1332         if (winNum == win)
1333         {
1334             continue;
1335         }
1336
1337                 /* Get window parameters        */
1338                 if (MV_OK != mvPexTargetWinGet(pexIf, win, &addrDecWin))
1339                 {
1340                         mvOsPrintf("pexWinOverlapDetect: ERR. TargetWinGet failed win=%x\n",
1341                                            win);
1342             return MV_ERROR;
1343                 }
1344
1345                 /* Do not check disabled windows        */
1346                 if (MV_FALSE == addrDecWin.enable)
1347                 {
1348                         continue;
1349                 }
1350
1351
1352         if(MV_TRUE == ctrlWinOverlapTest(pAddrWin, &addrDecWin.addrWin))
1353                 {
1354                         mvOsPrintf("pexWinOverlapDetect: winNum %d overlap current %d\n",
1355                                                                                                                         winNum, win);
1356                         return MV_TRUE;
1357                 }
1358     }
1359
1360         return MV_FALSE;
1361 }
1362
1363 /*******************************************************************************
1364 * pexIsWinWithinBar - Detect if address is within PEX bar boundries
1365 *
1366 * DESCRIPTION:
1367 *
1368 * INPUT:
1369 *
1370 * OUTPUT:
1371 *       None.
1372 *
1373 * RETURN:
1374 *       MV_TRUE if the given address window overlap current address
1375 *       decode map, MV_FALSE otherwise.
1376 *
1377 *******************************************************************************/
1378 static MV_BOOL pexIsWinWithinBar(MV_U32 pexIf,
1379                                                                    MV_ADDR_WIN *pAddrWin)
1380 {
1381     MV_U32                 bar;
1382         MV_PEX_BAR addrDecWin;
1383
1384         for(bar = 0; bar < PEX_MAX_BARS; bar++)
1385     {
1386
1387                 /* Get window parameters        */
1388                 if (MV_OK != mvPexBarGet(pexIf, bar, &addrDecWin))
1389                 {
1390                         mvOsPrintf("pexIsWinWithinBar: ERR. mvPexBarGet failed\n");
1391             return MV_ERROR;
1392                 }
1393
1394                 /* Do not check disabled bars   */
1395                 if (MV_FALSE == addrDecWin.enable)
1396                 {
1397                         continue;
1398                 }
1399
1400
1401         if(MV_TRUE == ctrlWinWithinWinTest(pAddrWin, &addrDecWin.addrWin))
1402                 {
1403                         return MV_TRUE;
1404                 }
1405     }
1406
1407         return MV_FALSE;
1408
1409 }
1410
1411 /*******************************************************************************
1412 * pexBarOverlapDetect - Detect address windows overlapping
1413 *
1414 * DESCRIPTION:
1415 *       This function detects address window overlapping of a given address
1416 *       window in PEX BARs.
1417 *
1418 * INPUT:
1419 *       pAddrWin - Address window to be checked.
1420 *       bar      - BAR to be accessed by slave.
1421 *
1422 * OUTPUT:
1423 *       None.
1424 *
1425 * RETURN:
1426 *       MV_TRUE if the given address window overlap current address
1427 *       decode map, MV_FALSE otherwise.
1428 *
1429 *******************************************************************************/
1430 static MV_BOOL pexBarOverlapDetect(MV_U32 pexIf,
1431                                                                          MV_U32 barNum,
1432                                                                          MV_ADDR_WIN *pAddrWin)
1433 {
1434     MV_U32                 bar;
1435         MV_PEX_BAR barDecWin;
1436
1437
1438         for(bar = 0; bar < PEX_MAX_BARS; bar++)
1439     {
1440         /* don't check our target or illegal targets */
1441         if (barNum == bar)
1442         {
1443             continue;
1444         }
1445
1446                 /* Get window parameters        */
1447                 if (MV_OK != mvPexBarGet(pexIf, bar, &barDecWin))
1448                 {
1449                         mvOsPrintf("pexBarOverlapDetect: ERR. TargetWinGet failed\n");
1450             return MV_ERROR;
1451                 }
1452
1453                 /* don'nt check disabled bars */
1454         if (barDecWin.enable == MV_FALSE)
1455                 {
1456                         continue;
1457                 }
1458
1459
1460         if(MV_TRUE == ctrlWinOverlapTest(pAddrWin, &barDecWin.addrWin))
1461                 {
1462                         mvOsPrintf("pexBarOverlapDetect: winNum %d overlap current %d\n",
1463                                                                                                                         barNum, bar);
1464                         return MV_TRUE;
1465                 }
1466     }
1467
1468         return MV_FALSE;
1469 }
1470
1471 /*******************************************************************************
1472 * pexBarIsValid - Check if the given address window is valid
1473 *
1474 * DESCRIPTION:
1475 *               PEX spec restrict BAR base to be aligned to BAR size.
1476 *               This function checks if the given address window is valid.
1477 *
1478 * INPUT:
1479 *       baseLow - 32bit low base address.
1480 *       size    - Window size.
1481 *
1482 * OUTPUT:
1483 *       None.
1484 *
1485 * RETURN:
1486 *       MV_TRUE if the address window is valid, MV_FALSE otherwise.
1487 *
1488 *******************************************************************************/
1489 static MV_STATUS pexBarIsValid(MV_U32 baseLow, MV_U32 size)
1490 {
1491
1492         /* PCI spec restrict BAR base to be aligned to BAR size                                 */
1493         if(MV_IS_NOT_ALIGN(baseLow, size))
1494         {
1495                 return MV_ERROR;
1496         }
1497         else
1498         {
1499                 return MV_TRUE;
1500         }
1501
1502         return MV_TRUE;
1503 }
1504
1505 /*******************************************************************************
1506 * pexBarRegInfoGet - Get BAR register information
1507 *
1508 * DESCRIPTION:
1509 *               PEX BARs registers offsets are inconsecutive.
1510 *               This function gets a PEX BAR register information like register offsets
1511 *               and function location of the BAR.
1512 *
1513 * INPUT:
1514 *       pexIf - PEX interface number.
1515 *               bar       - The PEX BAR in question.
1516 *
1517 * OUTPUT:
1518 *       pBarRegInfo - BAR register info struct.
1519 *
1520 * RETURN:
1521 *               MV_BAD_PARAM when bad parameters ,MV_ERROR on error ,othewise MV_OK
1522 *
1523 *******************************************************************************/
1524 static MV_STATUS pexWinRegInfoGet(MV_U32 pexIf,
1525                                                                   MV_U32 winNum,
1526                                                                   PEX_WIN_REG_INFO *pWinRegInfo)
1527 {
1528
1529         if ((winNum >= 0)&&(winNum <=3))
1530         {
1531                 pWinRegInfo->baseLowRegOffs   = PEX_WIN0_3_BASE_REG(pexIf,winNum);
1532                 pWinRegInfo->baseHighRegOffs  = 0;
1533                 pWinRegInfo->sizeRegOffs      = PEX_WIN0_3_CTRL_REG(pexIf,winNum);
1534                 pWinRegInfo->remapLowRegOffs  = PEX_WIN0_3_REMAP_REG(pexIf,winNum);
1535                 pWinRegInfo->remapHighRegOffs = 0;
1536         }
1537         else if ((winNum >= 4)&&(winNum <=5))
1538         {
1539                 pWinRegInfo->baseLowRegOffs   = PEX_WIN4_5_BASE_REG(pexIf,winNum);
1540                 pWinRegInfo->baseHighRegOffs  = 0;
1541                 pWinRegInfo->sizeRegOffs      = PEX_WIN4_5_CTRL_REG(pexIf,winNum);
1542                 pWinRegInfo->remapLowRegOffs  = PEX_WIN4_5_REMAP_REG(pexIf,winNum);
1543                 pWinRegInfo->remapHighRegOffs = PEX_WIN4_5_REMAP_HIGH_REG(pexIf,winNum);
1544
1545         }
1546         else if (MV_PEX_WIN_DEFAULT == winNum)
1547         {
1548                 pWinRegInfo->baseLowRegOffs   = 0;
1549                 pWinRegInfo->baseHighRegOffs  = 0;
1550                 pWinRegInfo->sizeRegOffs      = PEX_WIN_DEFAULT_CTRL_REG(pexIf);
1551                 pWinRegInfo->remapLowRegOffs  = 0;
1552                 pWinRegInfo->remapHighRegOffs = 0;
1553         }
1554         else if (MV_PEX_WIN_EXP_ROM == winNum)
1555         {
1556                 pWinRegInfo->baseLowRegOffs   = 0;
1557                 pWinRegInfo->baseHighRegOffs  = 0;
1558                 pWinRegInfo->sizeRegOffs      = PEX_WIN_EXP_ROM_CTRL_REG(pexIf);
1559                 pWinRegInfo->remapLowRegOffs  = PEX_WIN_EXP_ROM_REMAP_REG(pexIf);
1560                 pWinRegInfo->remapHighRegOffs = 0;
1561
1562         }
1563
1564         return MV_OK;
1565 }
1566
1567 /*******************************************************************************
1568 * pexBarNameGet - Get the string name of PEX BAR.
1569 *
1570 * DESCRIPTION:
1571 *               This function get the string name of PEX BAR.
1572 *
1573 * INPUT:
1574 *       bar - PEX bar number.
1575 *
1576 * OUTPUT:
1577 *       None.
1578 *
1579 * RETURN:
1580 *       pointer to the string name of PEX BAR.
1581 *
1582 *******************************************************************************/
1583 const MV_8* pexBarNameGet( MV_U32 bar )
1584 {
1585         switch( bar )
1586         {
1587                 case PEX_INTER_REGS_BAR:
1588                         return "Internal Regs Bar0....";
1589                 case PEX_DRAM_BAR:
1590                         return "DRAM Bar1.............";
1591                 case PEX_DEVICE_BAR:
1592                         return "Devices Bar2..........";
1593                 default:
1594                          return "Bar unknown";
1595         }
1596 }
1597 /*******************************************************************************
1598 * mvPexAddrDecShow - Print the PEX address decode map (BARs and windows).
1599 *
1600 * DESCRIPTION:
1601 *               This function print the PEX address decode map (BARs and windows).
1602 *
1603 * INPUT:
1604 *       None.
1605 *
1606 * OUTPUT:
1607 *       None.
1608 *
1609 * RETURN:
1610 *       None.
1611 *
1612 *******************************************************************************/
1613 MV_VOID mvPexAddrDecShow(MV_VOID)
1614 {
1615         MV_PEX_BAR pexBar;
1616         MV_PEX_DEC_WIN win;
1617         MV_U32 pexIf;
1618         MV_U32 bar,winNum;
1619
1620         for( pexIf = 0; pexIf < mvCtrlPexMaxIfGet(); pexIf++ )
1621         {
1622                 if (MV_FALSE == mvCtrlPwrClckGet(PEX_UNIT_ID, pexIf)) continue;
1623                 mvOsOutput( "\n" );
1624                 mvOsOutput( "PEX%d:\n", pexIf );
1625                 mvOsOutput( "-----\n" );
1626
1627                 mvOsOutput( "\nPex Bars \n\n");
1628
1629                 for( bar = 0; bar < PEX_MAX_BARS; bar++ )
1630                 {
1631                         memset( &pexBar, 0, sizeof(MV_PEX_BAR) );
1632
1633                         mvOsOutput( "%s ", pexBarNameGet(bar) );
1634
1635                         if( mvPexBarGet( pexIf, bar, &pexBar ) == MV_OK )
1636                         {
1637                                 if( pexBar.enable )
1638                                 {
1639                     mvOsOutput( "base %08x, ", pexBar.addrWin.baseLow );
1640                     mvSizePrint( pexBar.addrWin.size );
1641                     mvOsOutput( "\n" );
1642                                 }
1643                                 else
1644                                         mvOsOutput( "disable\n" );
1645                         }
1646                 }
1647                 mvOsOutput( "\nPex Decode Windows\n\n");
1648
1649                 for( winNum = 0; winNum < PEX_MAX_TARGET_WIN - 2; winNum++)
1650                 {
1651                         memset( &win, 0,sizeof(MV_PEX_DEC_WIN) );
1652
1653                         mvOsOutput( "win%d - ", winNum );
1654
1655                         if ( mvPexTargetWinGet(pexIf,winNum,&win) == MV_OK)
1656                         {
1657                                 if (win.enable)
1658                                 {
1659                                         mvOsOutput( "%s base %08x, ",
1660                                         mvCtrlTargetNameGet(win.target), win.addrWin.baseLow );
1661                                         mvOsOutput( "...." );
1662                                         mvSizePrint( win.addrWin.size );
1663
1664                                         mvOsOutput( "\n" );
1665                                 }
1666                                 else
1667                                         mvOsOutput( "disable\n" );
1668
1669
1670                         }
1671                 }
1672
1673                 memset( &win, 0,sizeof(MV_PEX_DEC_WIN) );
1674
1675                 mvOsOutput( "default win - " );
1676
1677                 if ( mvPexTargetWinGet(pexIf, MV_PEX_WIN_DEFAULT, &win) == MV_OK)
1678                 {
1679                         mvOsOutput( "%s ",
1680                         mvCtrlTargetNameGet(win.target) );
1681                         mvOsOutput( "\n" );
1682                 }
1683                 memset( &win, 0,sizeof(MV_PEX_DEC_WIN) );
1684
1685                 mvOsOutput( "Expansion ROM - " );
1686
1687                 if ( mvPexTargetWinGet(pexIf, MV_PEX_WIN_EXP_ROM, &win) == MV_OK)
1688                 {
1689                         mvOsOutput( "%s ",
1690                         mvCtrlTargetNameGet(win.target) );
1691                         mvOsOutput( "\n" );
1692                 }
1693
1694         }
1695 }
1696
1697