target/linux/generic-2.6/files/crypto/ocf/kirkwood/mvHal/mv_hal/pci-if/mvPciIf.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 "mvPciIf.h"
  66 #include "ctrlEnv/sys/mvSysPex.h"
  67
  68 #if defined(MV_INCLUDE_PCI)
  69 #include "ctrlEnv/sys/mvSysPci.h"
  70 #endif
  71
  72
  73 /* defines  */
  74 #ifdef MV_DEBUG
  75         #define DB(x)   x
  76 #else
  77         #define DB(x)
  78 #endif
  79
  80
  81 /*******************************************************************************
  82 * mvPciInit - Initialize PCI interfaces
  83 *
  84 * DESCRIPTION:
  85 *
  86 * INPUT:
  87 *
  88 *
  89 * OUTPUT:
  90 *       None.
  91 *
  92 * RETURN:
  93 *       MV_OK if function success otherwise MV_ERROR or MV_BAD_PARAM
  94 *
  95 *******************************************************************************/
  96
  97
  98 MV_STATUS mvPciIfInit(MV_U32 pciIf, PCI_IF_MODE pciIfmode)
  99 {
 100         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 101
 102         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 103         {
 104                 #if defined(MV_INCLUDE_PCI)
 105
 106         MV_PCI_MOD pciMod;
 107
 108         if (PCI_IF_MODE_HOST == pciIfmode)
 109         {
 110             pciMod = MV_PCI_MOD_HOST;
 111         }
 112         else if (PCI_IF_MODE_DEVICE == pciIfmode)
 113         {
 114             pciMod = MV_PCI_MOD_DEVICE;
 115         }
 116         else
 117         {
 118             mvOsPrintf("%s: ERROR!!! Bus %d mode %d neither host nor device!\n",
 119                         __FUNCTION__, pciIf, pciIfmode);
 120             return MV_FAIL;
 121         }
 122
 123         return mvPciInit(pciIf - MV_PCI_START_IF, pciMod);
 124                 #else
 125                 return MV_OK;
 126                 #endif
 127         }
 128         else if (PCI_IF_TYPE_PEX == pciIfType)
 129         {
 130                 #if defined(MV_INCLUDE_PEX)
 131
 132         MV_PEX_TYPE pexType;
 133
 134         if (PCI_IF_MODE_HOST == pciIfmode)
 135         {
 136             pexType = MV_PEX_ROOT_COMPLEX;
 137         }
 138         else if (PCI_IF_MODE_DEVICE == pciIfmode)
 139         {
 140             pexType = MV_PEX_END_POINT;
 141         }
 142         else
 143         {
 144             mvOsPrintf("%s: ERROR!!! Bus %d type %d neither root complex nor" \
 145                        " end point\n", __FUNCTION__, pciIf, pciIfmode);
 146             return MV_FAIL;
 147         }
 148                 return mvPexInit(pciIf - MV_PEX_START_IF, pexType);
 149
 150                 #else
 151                 return MV_OK;
 152                 #endif
 153
 154         }
 155         else
 156         {
 157                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 158         }
 159
 160         return MV_FAIL;
 161
 162 }
 163
 164 /* PCI configuration space read write */
 165
 166 /*******************************************************************************
 167 * mvPciConfigRead - Read from configuration space
 168 *
 169 * DESCRIPTION:
 170 *       This function performs a 32 bit read from PCI configuration space.
 171 *       It supports both type 0 and type 1 of Configuration Transactions
 172 *       (local and over bridge). In order to read from local bus segment, use
 173 *       bus number retrieved from mvPciLocalBusNumGet(). Other bus numbers
 174 *       will result configuration transaction of type 1 (over bridge).
 175 *
 176 * INPUT:
 177 *       pciIf   - PCI interface number.
 178 *       bus     - PCI segment bus number.
 179 *       dev     - PCI device number.
 180 *       func    - Function number.
 181 *       regOffs - Register offset.
 182 *
 183 * OUTPUT:
 184 *       None.
 185 *
 186 * RETURN:
 187 *       32bit register data, 0xffffffff on error
 188 *
 189 *******************************************************************************/
 190 MV_U32 mvPciIfConfigRead (MV_U32 pciIf, MV_U32 bus, MV_U32 dev, MV_U32 func,
 191                         MV_U32 regOff)
 192 {
 193         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 194
 195         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 196         {
 197                 #if defined(MV_INCLUDE_PCI)
 198                 return mvPciConfigRead(pciIf - MV_PCI_START_IF,
 199                                                                 bus,
 200                                                                 dev,
 201                                 func,
 202                                                                 regOff);
 203                 #else
 204                 return 0xffffffff;
 205                 #endif
 206         }
 207         else if (PCI_IF_TYPE_PEX == pciIfType)
 208         {
 209                 #if defined(MV_INCLUDE_PEX)
 210                 return mvPexConfigRead(pciIf - MV_PEX_START_IF,
 211                                                                 bus,
 212                                                                 dev,
 213                                 func,
 214                                                                 regOff);
 215                 #else
 216                 return 0xffffffff;
 217                 #endif
 218
 219         }
 220         else
 221         {
 222                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 223         }
 224
 225         return 0;
 226
 227 }
 228
 229 /*******************************************************************************
 230 * mvPciConfigWrite - Write to configuration space
 231 *
 232 * DESCRIPTION:
 233 *       This function performs a 32 bit write to PCI configuration space.
 234 *       It supports both type 0 and type 1 of Configuration Transactions
 235 *       (local and over bridge). In order to write to local bus segment, use
 236 *       bus number retrieved from mvPciLocalBusNumGet(). Other bus numbers
 237 *       will result configuration transaction of type 1 (over bridge).
 238 *
 239 * INPUT:
 240 *       pciIf   - PCI interface number.
 241 *       bus     - PCI segment bus number.
 242 *       dev     - PCI device number.
 243 *       func    - Function number.
 244 *       regOffs - Register offset.
 245 *       data    - 32bit data.
 246 *
 247 * OUTPUT:
 248 *       None.
 249 *
 250 * RETURN:
 251 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 252 *
 253 *******************************************************************************/
 254 MV_STATUS mvPciIfConfigWrite(MV_U32 pciIf, MV_U32 bus, MV_U32 dev,
 255                            MV_U32 func, MV_U32 regOff, MV_U32 data)
 256 {
 257         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 258
 259         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 260         {
 261                 #if defined(MV_INCLUDE_PCI)
 262                 return mvPciConfigWrite(pciIf - MV_PCI_START_IF,
 263                                                                 bus,
 264                                                                 dev,
 265                                 func,
 266                                                                 regOff,
 267                                                                 data);
 268                 #else
 269                 return MV_OK;
 270                 #endif
 271         }
 272         else if (PCI_IF_TYPE_PEX == pciIfType)
 273         {
 274                 #if defined(MV_INCLUDE_PEX)
 275                 return mvPexConfigWrite(pciIf - MV_PEX_START_IF,
 276                                                                 bus,
 277                                                                 dev,
 278                                 func,
 279                                                                 regOff,
 280                                                                 data);
 281                 #else
 282                 return MV_OK;
 283                 #endif
 284
 285         }
 286         else
 287         {
 288                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 289         }
 290
 291         return MV_FAIL;
 292
 293 }
 294
 295 /*******************************************************************************
 296 * mvPciMasterEnable - Enable/disale PCI interface master transactions.
 297 *
 298 * DESCRIPTION:
 299 *       This function performs read modified write to PCI command status
 300 *       (offset 0x4) to set/reset bit 2. After this bit is set, the PCI
 301 *       master is allowed to gain ownership on the bus, otherwise it is
 302 *       incapable to do so.
 303 *
 304 * INPUT:
 305 *       pciIf  - PCI interface number.
 306 *       enable - Enable/disable parameter.
 307 *
 308 * OUTPUT:
 309 *       None.
 310 *
 311 * RETURN:
 312 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 313 *
 314 *******************************************************************************/
 315 MV_STATUS mvPciIfMasterEnable(MV_U32 pciIf, MV_BOOL enable)
 316 {
 317
 318         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 319
 320         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 321         {
 322                 #if defined(MV_INCLUDE_PCI)
 323                 return mvPciMasterEnable(pciIf - MV_PCI_START_IF,
 324                                                                 enable);
 325                 #else
 326                 return MV_OK;
 327                 #endif
 328         }
 329         else if (PCI_IF_TYPE_PEX == pciIfType)
 330         {
 331                 #if defined(MV_INCLUDE_PEX)
 332                 return mvPexMasterEnable(pciIf - MV_PEX_START_IF,
 333                                                                 enable);
 334                 #else
 335                 return MV_OK;
 336                 #endif
 337         }
 338         else
 339         {
 340                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 341         }
 342
 343         return MV_FAIL;
 344
 345 }
 346
 347
 348 /*******************************************************************************
 349 * mvPciSlaveEnable - Enable/disale PCI interface slave transactions.
 350 *
 351 * DESCRIPTION:
 352 *       This function performs read modified write to PCI command status
 353 *       (offset 0x4) to set/reset bit 0 and 1. After those bits are set,
 354 *       the PCI slave is allowed to respond to PCI IO space access (bit 0)
 355 *       and PCI memory space access (bit 1).
 356 *
 357 * INPUT:
 358 *       pciIf  - PCI interface number.
 359 *       dev     - PCI device number.
 360 *       enable - Enable/disable parameter.
 361 *
 362 * OUTPUT:
 363 *       None.
 364 *
 365 * RETURN:
 366 *       MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
 367 *
 368 *******************************************************************************/
 369 MV_STATUS mvPciIfSlaveEnable(MV_U32 pciIf,MV_U32 bus, MV_U32 dev, MV_BOOL enable)
 370 {
 371
 372         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 373
 374         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 375         {
 376                 #if defined(MV_INCLUDE_PCI)
 377                 return mvPciSlaveEnable(pciIf - MV_PCI_START_IF,bus,dev,
 378                                                                 enable);
 379                 #else
 380                 return MV_OK;
 381                 #endif
 382         }
 383         else if (PCI_IF_TYPE_PEX == pciIfType)
 384         {
 385                 #if defined(MV_INCLUDE_PEX)
 386                 return mvPexSlaveEnable(pciIf - MV_PEX_START_IF,bus,dev,
 387                                                                 enable);
 388                 #else
 389                 return MV_OK;
 390                 #endif
 391         }
 392         else
 393         {
 394                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 395         }
 396
 397         return MV_FAIL;
 398
 399 }
 400
 401 /*******************************************************************************
 402 * mvPciLocalBusNumSet - Set PCI interface local bus number.
 403 *
 404 * DESCRIPTION:
 405 *       This function sets given PCI interface its local bus number.
 406 *       Note: In case the PCI interface is PCI-X, the information is read-only.
 407 *
 408 * INPUT:
 409 *       pciIf  - PCI interface number.
 410 *       busNum - Bus number.
 411 *
 412 * OUTPUT:
 413 *       None.
 414 *
 415 * RETURN:
 416 *       MV_NOT_ALLOWED in case PCI interface is PCI-X.
 417 *               MV_BAD_PARAM on bad parameters ,
 418 *       otherwise MV_OK
 419 *
 420 *******************************************************************************/
 421 MV_STATUS mvPciIfLocalBusNumSet(MV_U32 pciIf, MV_U32 busNum)
 422 {
 423         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 424
 425         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 426         {
 427                 #if defined(MV_INCLUDE_PCI)
 428                 return mvPciLocalBusNumSet(pciIf - MV_PCI_START_IF,
 429                                                                 busNum);
 430                 #else
 431                 return MV_OK;
 432                 #endif
 433     }
 434     else if (PCI_IF_TYPE_PEX == pciIfType)
 435         {
 436                 #if defined(MV_INCLUDE_PEX)
 437                 return mvPexLocalBusNumSet(pciIf - MV_PEX_START_IF,
 438                                                                 busNum);
 439                 #else
 440                 return MV_OK;
 441                 #endif
 442         }
 443         else
 444         {
 445                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 446         }
 447
 448         return MV_FAIL;
 449
 450 }
 451
 452 /*******************************************************************************
 453 * mvPciLocalBusNumGet - Get PCI interface local bus number.
 454 *
 455 * DESCRIPTION:
 456 *       This function gets the local bus number of a given PCI interface.
 457 *
 458 * INPUT:
 459 *       pciIf  - PCI interface number.
 460 *
 461 * OUTPUT:
 462 *       None.
 463 *
 464 * RETURN:
 465 *       Local bus number.0xffffffff on Error
 466 *
 467 *******************************************************************************/
 468 MV_U32 mvPciIfLocalBusNumGet(MV_U32 pciIf)
 469 {
 470         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 471
 472         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 473         {
 474                 #if defined(MV_INCLUDE_PCI)
 475                 return mvPciLocalBusNumGet(pciIf - MV_PCI_START_IF);
 476                 #else
 477                 return 0xFFFFFFFF;
 478                 #endif
 479         }
 480         else if (PCI_IF_TYPE_PEX == pciIfType)
 481         {
 482                 #if defined(MV_INCLUDE_PEX)
 483                 return mvPexLocalBusNumGet(pciIf - MV_PEX_START_IF);
 484                 #else
 485                 return 0xFFFFFFFF;
 486                 #endif
 487
 488         }
 489         else
 490         {
 491                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n",__FUNCTION__, pciIf);
 492         }
 493
 494         return 0;
 495
 496 }
 497
 498
 499 /*******************************************************************************
 500 * mvPciLocalDevNumSet - Set PCI interface local device number.
 501 *
 502 * DESCRIPTION:
 503 *       This function sets given PCI interface its local device number.
 504 *       Note: In case the PCI interface is PCI-X, the information is read-only.
 505 *
 506 * INPUT:
 507 *       pciIf  - PCI interface number.
 508 *       devNum - Device number.
 509 *
 510 * OUTPUT:
 511 *       None.
 512 *
 513 * RETURN:
 514 *       MV_NOT_ALLOWED in case PCI interface is PCI-X. MV_BAD_PARAM on bad parameters ,
 515 *       otherwise MV_OK
 516 *
 517 *******************************************************************************/
 518 MV_STATUS mvPciIfLocalDevNumSet(MV_U32 pciIf, MV_U32 devNum)
 519 {
 520         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 521
 522         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 523         {
 524                 #if defined(MV_INCLUDE_PCI)
 525                 return mvPciLocalDevNumSet(pciIf - MV_PCI_START_IF,
 526                                                                 devNum);
 527                 #else
 528                 return MV_OK;
 529                 #endif
 530         }
 531         else if (PCI_IF_TYPE_PEX == pciIfType)
 532         {
 533                 #if defined(MV_INCLUDE_PEX)
 534                 return mvPexLocalDevNumSet(pciIf - MV_PEX_START_IF,
 535                                                                 devNum);
 536                 #else
 537                 return MV_OK;
 538                 #endif
 539         }
 540         else
 541         {
 542                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 543         }
 544
 545         return MV_FAIL;
 546
 547 }
 548
 549 /*******************************************************************************
 550 * mvPciLocalDevNumGet - Get PCI interface local device number.
 551 *
 552 * DESCRIPTION:
 553 *       This function gets the local device number of a given PCI interface.
 554 *
 555 * INPUT:
 556 *       pciIf  - PCI interface number.
 557 *
 558 * OUTPUT:
 559 *       None.
 560 *
 561 * RETURN:
 562 *       Local device number. 0xffffffff on Error
 563 *
 564 *******************************************************************************/
 565 MV_U32 mvPciIfLocalDevNumGet(MV_U32 pciIf)
 566 {
 567         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 568
 569         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 570         {
 571                 #if defined(MV_INCLUDE_PCI)
 572                 return mvPciLocalDevNumGet(pciIf - MV_PCI_START_IF);
 573                 #else
 574                 return 0xFFFFFFFF;
 575                 #endif
 576         }
 577         else if (PCI_IF_TYPE_PEX == pciIfType)
 578         {
 579                 #if defined(MV_INCLUDE_PEX)
 580                 return mvPexLocalDevNumGet(pciIf - MV_PEX_START_IF);
 581                 #else
 582                 return 0xFFFFFFFF;
 583                 #endif
 584
 585         }
 586         else
 587         {
 588                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 589         }
 590
 591         return 0;
 592
 593 }
 594
 595 /*******************************************************************************
 596 * mvPciIfTypeGet -
 597 *
 598 * DESCRIPTION:
 599 *
 600 * INPUT:
 601 *
 602 * OUTPUT:
 603 *       None.
 604 *
 605 * RETURN:
 606 *
 607 *******************************************************************************/
 608
 609 PCI_IF_TYPE mvPciIfTypeGet(MV_U32 pciIf)
 610 {
 611
 612         if ((pciIf >= MV_PCI_START_IF)&&(pciIf < MV_PCI_MAX_IF + MV_PCI_START_IF))
 613         {
 614                 return PCI_IF_TYPE_CONVEN_PCIX;
 615         }
 616         else if ((pciIf >= MV_PEX_START_IF) &&
 617                          (pciIf < MV_PEX_MAX_IF + MV_PEX_START_IF))
 618         {
 619                 return PCI_IF_TYPE_PEX;
 620
 621         }
 622         else
 623         {
 624                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 625         }
 626
 627         return 0xffffffff;
 628
 629 }
 630
 631 /*******************************************************************************
 632 * mvPciIfTypeGet -
 633 *
 634 * DESCRIPTION:
 635 *
 636 * INPUT:
 637 *
 638 * OUTPUT:
 639 *       None.
 640 *
 641 * RETURN:
 642 *
 643 *******************************************************************************/
 644
 645 MV_U32  mvPciRealIfNumGet(MV_U32 pciIf)
 646 {
 647
 648         PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
 649
 650         if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
 651         {
 652                 return (pciIf - MV_PCI_START_IF);
 653         }
 654         else if (PCI_IF_TYPE_PEX == pciIfType)
 655         {
 656                 return (pciIf - MV_PEX_START_IF);
 657
 658         }
 659         else
 660         {
 661                 mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
 662         }
 663
 664         return 0xffffffff;
 665
 666 }
 667
 668
 669