pvr/services4/system/common/sysconfig.c

   1 /* -*- syscommon-c -*-
   2  *-----------------------------------------------------------------------------
   3  * Filename: syscommon.c
   4  * $Revision: 1.11 $
   5  *-----------------------------------------------------------------------------
   6  * Copyright (c) 2002-2010, Intel Corporation.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  *
  26  *-----------------------------------------------------------------------------
  27  * Description: platform detection, and sharing of correct platform interface.
  28  *
  29  *-----------------------------------------------------------------------------
  30  */
  31
  32 #include <linux/pci.h>
  33 #include "sgxdefs.h"
  34 #include "services_headers.h"
  35 #include "kerneldisplay.h"
  36 #include "oemfuncs.h"
  37 #include "sgxinfo.h"
  38 #include "sgxinfokm.h"
  39 #ifdef SUPPORT_MSVDX
  40 #include "msvdx_defs.h"
  41 #include "msvdxapi.h"
  42 #include "msvdx_infokm.h"
  43 #include "osfunc.h"
  44 #endif
  45 #include "pdump_km.h"
  46 #include "syslocal.h"
  47 #include "sysconfig.h"
  48 #include "pvr_debug.h"
  49 #include "msvdx_pvr.h"
  50
  51 /* --------------------------------------------------------------------------*/
  52 /**
  53 * @Synopsis Pointer to "System Data" used by all platform blocks, exported
  54 * in "syscommon.h" header file.
  55 */
  56 /* --------------------------------------------------------------------------*/
  57 SYS_DATA *gpsSysData = (SYS_DATA*)IMG_NULL;
  58
  59 /* --------------------------------------------------------------------------*/
  60 /**
  61 * @Synopsis Pointer to found platform interface. It is IMG_NULL when no
  62 * correct platform can be found.
  63 */
  64 /* --------------------------------------------------------------------------*/
  65 SYS_PLATFORM_INTERFACE *gpsSysPlatformInterface = (SYS_PLATFORM_INTERFACE*)IMG_NULL;
  66
  67
  68 /* --------------------------------------------------------------------------*/
  69 /**
  70 * @Synopsis Poulsbo platform interface.
  71 */
  72 /* --------------------------------------------------------------------------*/
  73 extern SYS_PLATFORM_INTERFACE gpsSysPlatformInterfacePlb;
  74
  75 /* --------------------------------------------------------------------------*/
  76 /**
  77 * @Synopsis Atom E6xx platform interface.
  78 */
  79 /* --------------------------------------------------------------------------*/
  80 extern SYS_PLATFORM_INTERFACE gpsSysPlatformInterfaceTnc;
  81
  82 /* --------------------------------------------------------------------------*/
  83 /**
  84 * @Synopsis Table to available platforms interfaces.
  85 * The last element must be set to IMG_NULL.
  86 *
  87 * @Param &gpsSysPlatformInterfacePlb Poulsbo interface
  88 * @Param &gpsSysPlatformInterfaceTnc Atom E6xx interface
  89 */
  90 /* --------------------------------------------------------------------------*/
  91 SYS_PLATFORM_INTERFACE* gpsSysPlatformInterfacesTab[] = {       &gpsSysPlatformInterfacePlb,
  92                                                                 &gpsSysPlatformInterfaceTnc,
  93                                                                 (SYS_PLATFORM_INTERFACE*)IMG_NULL};
  94
  95
  96 /* --------------------------------------------------------------------------*/
  97 /**
  98 * @Synopsis Function to detect platform and set "gpsSysPlatformInterface" to
  99 * one member of "gpsSysPlatformInterfacesTab".
 100 *
 101 * @Param IMG_VOID
 102 *
 103 * @Returns
 104 */
 105 /* --------------------------------------------------------------------------*/
 106 IMG_VOID SysPlatformDetect(IMG_VOID)
 107 {
 108         SYS_PLATFORM_INTERFACE** psSysPlatformInterfacesTab = gpsSysPlatformInterfacesTab;
 109
 110         while(*psSysPlatformInterfacesTab != IMG_NULL) {
 111
 112                 if(pci_get_device(SYS_SGX_DEV_VENDOR_ID, (unsigned short)((*psSysPlatformInterfacesTab)->uiSgxDevDeviceID), NULL)) {
 113                         gpsSysPlatformInterface = *psSysPlatformInterfacesTab;
 114                         PVR_DPF((PVR_DBG_MESSAGE,"Platform detected: %s", gpsSysPlatformInterface->sProductName));
 115                         return;
 116                 }
 117                 PVR_DPF((PVR_DBG_MESSAGE,"Platform search: %s", (*psSysPlatformInterfacesTab)->sProductName));
 118                 psSysPlatformInterfacesTab++;
 119         }
 120         PVR_DPF((PVR_DBG_ERROR,"Platform detected Failed"));
 121 }
 122
 123
 124 /* --------------------------------------------------------------------------*/
 125 /**
 126 * @Synopsis  Interface for Atom E6xx device
 127 */
 128 /* ----------------------------------------------------------------------------*/
 129
 130 static SYS_DATA  gsSysData;
 131
 132 static SYS_SPECIFIC_DATA gsSysSpecificData;
 133
 134 static IMG_UINT32               gui32SGXDeviceID;
 135 static SGX_DEVICE_MAP   gsSGXDeviceMap;
 136 static IMG_UINT32               gui32MSVDXDeviceID;
 137
 138 #ifdef SUPPORT_MSVDX
 139 static IMG_UINT32               gui32MSVDXDeviceID;
 140 static MSVDX_DEVICE_MAP gsMSVDXDeviceMap;
 141 #endif
 142
 143
 144 #if defined(NO_HARDWARE)
 145 static IMG_CPU_VIRTADDR gsSGXRegsCPUVAddr;
 146 #ifdef SUPPORT_MSVDX
 147 static IMG_CPU_VIRTADDR gsMSVDXRegsCPUVAddr;
 148 #endif
 149 #endif
 150
 151 #if !defined(NO_HARDWARE)
 152 static IMG_CPU_VIRTADDR gsPoulsboRegsCPUVaddr;
 153
 154 #if defined(MAP_UNUSED_MAPPINGS)
 155 static IMG_CPU_VIRTADDR gsPoulsboDisplayRegsCPUVaddr;
 156 #endif
 157
 158 #endif
 159
 160 #ifdef  LDM_PCI
 161 extern struct pci_dev *gpsPVRLDMDev;
 162 #endif
 163
 164 IMG_UINT32 PVRSRV_BridgeDispatchKM( IMG_UINT32  Ioctl,
 165                                                                         IMG_BYTE   *pInBuf,
 166                                                                         IMG_UINT32  InBufLen,
 167                                                                         IMG_BYTE   *pOutBuf,
 168                                                                         IMG_UINT32  OutBufLen,
 169                                                                         IMG_UINT32 *pdwBytesTransferred);
 170
 171 #ifdef __linux__
 172 #define ADDR_RANGE_INDEX        (MMADR_INDEX - 4)
 173 #if defined(SGX_FEATURE_HOST_PORT)
 174 #define HP_ADDR_RANGE_INDEX     (GMADR_INDEX - 4)
 175 #endif
 176 static PVRSRV_ERROR PCIInitDev(SYS_DATA *psSysData)
 177 {
 178         SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
 179
 180 #ifdef  LDM_PCI
 181         psSysSpecData->hSGXPCI = OSPCISetDev((IMG_VOID *)psSysSpecData->psPCIDev, HOST_PCI_INIT_FLAG_BUS_MASTER);
 182 #else
 183         psSysSpecData->hSGXPCI = OSPCIAcquireDev(SYS_SGX_DEV_VENDOR_ID, SYS_SGX_DEV_DEVICE_ID, HOST_PCI_INIT_FLAG_BUS_MASTER);
 184 #endif
 185         if (!psSysSpecData->hSGXPCI)
 186         {
 187                 PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Failed to acquire PCI device"));
 188                 return PVRSRV_ERROR_GENERIC;
 189         }
 190
 191          SYS_SPECIFIC_DATA_SET(psSysSpecData, SYS_SPECIFIC_DATA_PCI_ACQUIRE_DEV);
 192
 193         PVR_TRACE(("PCI memory region: %x to %x", OSPCIAddrRangeStart(psSysSpecData->hSGXPCI, ADDR_RANGE_INDEX), OSPCIAddrRangeEnd(psSysSpecData->hSGXPCI, ADDR_RANGE_INDEX)));
 194 #if defined(SGX_FEATURE_HOST_PORT)
 195         PVR_TRACE(("Host Port region: %x to %x", OSPCIAddrRangeStart(psSysSpecData->hSGXPCI, HP_ADDR_RANGE_INDEX), OSPCIAddrRangeEnd(psSysSpecData->hSGXPCI, HP_ADDR_RANGE_INDEX)));
 196 #endif
 197
 198         if (OSPCIAddrRangeLen(psSysSpecData->hSGXPCI, ADDR_RANGE_INDEX) < MAX_OFFSET)
 199         {
 200                 PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region isn't big enough"));
 201                 return PVRSRV_ERROR_GENERIC;
 202         }
 203
 204
 205         if (OSPCIRequestAddrRange(psSysSpecData->hSGXPCI, ADDR_RANGE_INDEX) != PVRSRV_OK)
 206         {
 207                 PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region not available"));
 208                 return PVRSRV_ERROR_GENERIC;
 209         }
 210          SYS_SPECIFIC_DATA_SET(psSysSpecData, SYS_SPECIFIC_DATA_PCI_REQUEST_SGX_ADDR_RANGE);
 211
 212
 213 #if defined(SGX_FEATURE_HOST_PORT)
 214         if (OSPCIRequestAddrRange(psSysSpecData->hSGXPCI, HP_ADDR_RANGE_INDEX) != PVRSRV_OK)
 215         {
 216                 PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Host Port region not available"));
 217                 return PVRSRV_ERROR_GENERIC;
 218         }
 219          SYS_SPECIFIC_DATA_SET(psSysSpecData, SYS_SPECIFIC_DATA_PCI_REQUEST_HOST_PORT_RANGE);
 220 #endif
 221         return PVRSRV_OK;
 222 }
 223
 224 static IMG_VOID PCIDeInitDev(SYS_DATA *psSysData)
 225 {
 226         SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
 227
 228         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_PCI_REQUEST_SGX_ADDR_RANGE))
 229         {
 230                 OSPCIReleaseAddrRange(psSysSpecData->hSGXPCI, ADDR_RANGE_INDEX);
 231         }
 232
 233 #if defined(SGX_FEATURE_HOST_PORT)
 234         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_PCI_REQUEST_HOST_PORT_RANGE))
 235         {
 236                 OSPCIReleaseAddrRange(psSysSpecData->hSGXPCI, HP_ADDR_RANGE_INDEX);
 237         }
 238 #endif
 239
 240         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_PCI_ACQUIRE_DEV))
 241         {
 242                 OSPCIReleaseDev(psSysSpecData->hSGXPCI);
 243         }
 244 }
 245 #else
 246 static PVRSRV_ERROR FindPCIDevice(IMG_UINT16 ui16VenID, IMG_UINT16 ui16DevID, PCICONFIG_SPACE *psPCISpace)
 247 {
 248         IMG_UINT32 ui32BusNum;
 249         IMG_UINT32 ui32DevNum;
 250         IMG_UINT32 ui32VenDevID;
 251
 252
 253         for (ui32BusNum=0; ui32BusNum < 255; ui32BusNum++)
 254         {
 255
 256                 for (ui32DevNum=0; ui32DevNum < 32; ui32DevNum++)
 257                 {
 258
 259                         ui32VenDevID=OSPCIReadDword(ui32BusNum, ui32DevNum, 0, 0);
 260
 261
 262                         if (ui32VenDevID == (IMG_UINT32)((ui16DevID<<16)+ui16VenID))
 263                         {
 264                                 IMG_UINT32 ui32Idx;
 265
 266
 267                                 OSPCIWriteDword(ui32BusNum, ui32DevNum, 0, 4, OSPCIReadDword(ui32BusNum, ui32DevNum, 0, 4) | 0x02);
 268
 269
 270                                 for (ui32Idx=0; ui32Idx < 64; ui32Idx++)
 271                                 {
 272                                         psPCISpace->u.aui32PCISpace[ui32Idx] = OSPCIReadDword(ui32BusNum, ui32DevNum, 0, ui32Idx*4);
 273
 274                                         if (ui32Idx < 16)
 275                                         {
 276                                                 PVR_DPF((PVR_DBG_VERBOSE,"%08X\n",psPCISpace->u.aui32PCISpace[ui32Idx]));
 277                                         }
 278                                 }
 279                                 return PVRSRV_OK;
 280                         }
 281
 282                 }
 283
 284         }
 285
 286         PVR_DPF((PVR_DBG_ERROR,"Couldn't find PCI device"));
 287
 288         return PVRSRV_ERROR_GENERIC;
 289 }
 290 #endif
 291
 292 static PVRSRV_ERROR SysLocateDevices(SYS_DATA *psSysData)
 293 {
 294 #if !defined(NO_HARDWARE) || defined(__linux__)
 295         IMG_UINT32 ui32BaseAddr;
 296         IMG_UINT32 ui32IRQ;
 297 #endif
 298 #if defined(SGX_FEATURE_HOST_PORT)
 299         IMG_UINT32 ui32HostPortAddr = 0UL;
 300 #endif
 301 #if defined(NO_HARDWARE)
 302         IMG_CPU_PHYADDR sCpuPAddr;
 303 #endif
 304 #if defined(NO_HARDWARE) || defined(__linux__)
 305         SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
 306 #endif
 307 #if (!defined(__linux__) || defined(NO_HARDWARE))
 308         PVRSRV_ERROR eError;
 309 #endif
 310
 311 #ifdef __linux__
 312         ui32BaseAddr = OSPCIAddrRangeStart(psSysSpecData->hSGXPCI, ADDR_RANGE_INDEX);
 313 #if defined(SGX_FEATURE_HOST_PORT)
 314         ui32HostPortAddr = OSPCIAddrRangeStart(psSysSpecData->hSGXPCI, HP_ADDR_RANGE_INDEX);
 315 #endif
 316         if (OSPCIIRQ(psSysSpecData->hSGXPCI, &ui32IRQ) != PVRSRV_OK)
 317         {
 318                 PVR_DPF((PVR_DBG_ERROR,"SysLocateDevices: Couldn't get IRQ"));
 319                 return PVRSRV_ERROR_INVALID_DEVICE;
 320         }
 321         PVR_TRACE(("IRQ: %d", ui32IRQ));
 322 #else
 323         PVRSRV_ERROR eError;
 324         PCICONFIG_SPACE sPCISpace;
 325
 326         eError = FindPCIDevice(VENDOR_ID, DEVICE_ID, &sPCISpace);
 327         if (eError == PVRSRV_OK)
 328         {
 329                 ui32BaseAddr = sPCISpace.u.aui32PCISpace[MMADR_INDEX];
 330 #if defined(SGX_FEATURE_HOST_PORT)
 331                 ui32HostPortAddr = sPCISpace.u.aui32PCISpace[GMADR_INDEX];
 332 #endif
 333         }
 334         else
 335         {
 336                 return PVRSRV_ERROR_INVALID_DEVICE;
 337         }
 338
 339         ui32IRQ = (IMG_UINT32)sPCISpace.u.aui8PCISpace[0x3C];
 340 #endif
 341
 342
 343         gsSGXDeviceMap.ui32Flags = 0x0;
 344
 345
 346 #if defined(NO_HARDWARE)
 347
 348         gsSGXDeviceMap.ui32IRQ = 0;
 349 #else
 350         gsSGXDeviceMap.ui32IRQ = ui32IRQ;
 351 #endif
 352
 353 #if defined(NO_HARDWARE)
 354
 355         eError = OSBaseAllocContigMemory(SGX_REG_SIZE,
 356                                                                                 &gsSGXRegsCPUVAddr,
 357                                                                                 &sCpuPAddr);
 358         if(eError != PVRSRV_OK)
 359         {
 360                 return eError;
 361         }
 362         SYS_SPECIFIC_DATA_SET(psSysSpecData, SYS_SPECIFIC_DATA_ALLOC_DUMMY_SGX_REGS);
 363
 364         gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;
 365
 366         OSMemSet(gsSGXRegsCPUVAddr, 0, SGX_REG_SIZE);
 367
 368 #if defined(__linux__)
 369
 370         gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;
 371 #else
 372
 373         gsSGXDeviceMap.pvRegsCpuVBase = IMG_NULL;
 374 #endif
 375
 376 #else
 377         gsSGXDeviceMap.sRegsSysPBase.uiAddr = ui32BaseAddr + SGX_REGS_OFFSET;
 378 #endif
 379
 380
 381         gsSGXDeviceMap.sRegsCpuPBase = SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sRegsSysPBase);
 382         gsSGXDeviceMap.ui32RegsSize = SGX_REG_SIZE;
 383
 384 #if defined(SGX_FEATURE_HOST_PORT)
 385
 386         gsSGXDeviceMap.ui32Flags = SGX_HOSTPORT_PRESENT;
 387         gsSGXDeviceMap.sHPSysPBase.uiAddr = ui32HostPortAddr;
 388         gsSGXDeviceMap.sHPCpuPBase = SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sHPSysPBase);
 389         gsSGXDeviceMap.ui32HPSize = SYS_SGX_HP_SIZE;
 390 #endif
 391
 392
 393
 394
 395         gsSGXDeviceMap.sLocalMemSysPBase.uiAddr = 0;
 396         gsSGXDeviceMap.sLocalMemDevPBase.uiAddr = 0;
 397         gsSGXDeviceMap.sLocalMemCpuPBase.uiAddr = 0;
 398         gsSGXDeviceMap.ui32LocalMemSize = 0;
 399
 400 #if !defined(NO_HARDWARE)
 401
 402         {
 403                 IMG_SYS_PHYADDR sPoulsboRegsCpuPBase;
 404
 405                 sPoulsboRegsCpuPBase.uiAddr = ui32BaseAddr + REGS_OFFSET;
 406                 gsPoulsboRegsCPUVaddr = OSMapPhysToLin(SysSysPAddrToCpuPAddr(sPoulsboRegsCpuPBase),
 407                                                                                                  REG_SIZE,
 408                                                                                                  PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
 409                                                                                                  IMG_NULL);
 410
 411 #if defined(MAP_UNUSED_MAPPINGS)
 412                 sPoulsboRegsCpuPBase.uiAddr = ui32BaseAddr + DISPLAY_REGS_OFFSET;
 413                 gsPoulsboDisplayRegsCPUVaddr = OSMapPhysToLin(SysSysPAddrToCpuPAddr(sPoulsboRegsCpuPBase),
 414                                                                                                  DISPLAY_REG_SIZE,
 415                                                                                                  PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
 416                                                                                                  IMG_NULL);
 417 #endif
 418         }
 419 #endif
 420
 421 #ifdef SUPPORT_MSVDX
 422
 423
 424 #if defined(NO_HARDWARE)
 425
 426         eError = OSBaseAllocContigMemory(MSVDX_REG_SIZE,
 427                                                                                 &gsMSVDXRegsCPUVAddr,
 428                                                                                 &sCpuPAddr);
 429         if(eError != PVRSRV_OK)
 430         {
 431                 return eError;
 432         }
 433         SYS_SPECIFIC_DATA_SET(psSysSpecData, SYS_SPECIFIC_DATA_ALLOC_DUMMY_MSVDX_REGS);
 434         gsMSVDXDeviceMap.sRegsCpuPBase = sCpuPAddr;
 435
 436         OSMemSet(gsMSVDXRegsCPUVAddr, 0, MSVDX_REG_SIZE);
 437
 438 #if defined(__linux__)
 439
 440         gsMSVDXDeviceMap.pvRegsCpuVBase = gsMSVDXRegsCPUVAddr;
 441 #else
 442
 443         gsMSVDXDeviceMap.pvRegsCpuVBase = IMG_NULL;
 444 #endif
 445 #else
 446         gsMSVDXDeviceMap.sRegsCpuPBase.uiAddr = ui32BaseAddr + MSVDX_REGS_OFFSET;
 447 #endif
 448         gsMSVDXDeviceMap.sRegsSysPBase            = SysCpuPAddrToSysPAddr(gsMSVDXDeviceMap.sRegsCpuPBase);
 449         gsMSVDXDeviceMap.ui32RegsSize             = MSVDX_REG_SIZE;
 450
 451
 452
 453
 454
 455         gsMSVDXDeviceMap.sLocalMemSysPBase.uiAddr = 0;
 456         gsMSVDXDeviceMap.sLocalMemDevPBase.uiAddr = 0;
 457         gsMSVDXDeviceMap.sLocalMemCpuPBase.uiAddr = 0;
 458         gsMSVDXDeviceMap.ui32LocalMemSize                 = 0;
 459
 460
 461
 462         gsMSVDXDeviceMap.ui32IRQ = ui32IRQ;
 463
 464 #endif
 465
 466
 467
 468         return PVRSRV_OK;
 469 }
 470
 471 #ifdef SUPPORT_MSVDX_FPGA
 472 static PVRSRV_ERROR FindPCIDevice(IMG_UINT16 ui16VenID, IMG_UINT16 ui16DevID, PCICONFIG_SPACE *psPCISpace)
 473 {
 474         IMG_UINT32  ui32BusNum;
 475         IMG_UINT32  ui32DevNum;
 476         IMG_UINT32  ui32VenDevID;
 477         IMG_UINT32      ui32BarIndex;
 478
 479
 480         for (ui32BusNum=0; ui32BusNum < 255; ui32BusNum++)
 481         {
 482
 483                 for (ui32DevNum=0; ui32DevNum < 32; ui32DevNum++)
 484                 {
 485
 486                         ui32VenDevID=OSPCIReadDword(ui32BusNum, ui32DevNum, 0, 0);
 487
 488
 489                         if (ui32VenDevID == (IMG_UINT32)((ui16DevID<<16)+ui16VenID))
 490                         {
 491                                 IMG_UINT32 ui32Idx;
 492
 493
 494                                 OSPCIWriteDword(ui32BusNum, ui32DevNum, 0, 4, OSPCIReadDword(ui32BusNum, ui32DevNum, 0, 4) | 0x02);
 495
 496                                 psPCISpace->ui32BusNum  = ui32BusNum;
 497                                 psPCISpace->ui32DevNum  = ui32DevNum;
 498                                 psPCISpace->ui32FuncNum = 0;
 499
 500
 501                                 for (ui32Idx=0; ui32Idx < 64; ui32Idx++)
 502                                 {
 503                                         psPCISpace->u.aui32PCISpace[ui32Idx] = OSPCIReadDword(ui32BusNum, ui32DevNum, 0, ui32Idx*4);
 504
 505                                         if (ui32Idx < 16)
 506                                         {
 507                                                 PVR_DPF((PVR_DBG_VERBOSE,"%08X\n",psPCISpace->u.aui32PCISpace[ui32Idx]));
 508                                         }
 509                                 }
 510
 511                                 for (ui32BarIndex = 0; ui32BarIndex < 6; ui32BarIndex++)
 512                                 {
 513                                         GetPCIMemSpaceSize (ui32BusNum, ui32DevNum, ui32BarIndex, &psPCISpace->aui32PCIMemSpaceSize[ui32BarIndex]);
 514                                 }
 515                                 return PVRSRV_OK;
 516                         }
 517
 518                 }
 519
 520         }
 521
 522         PVR_DPF((PVR_DBG_ERROR,"Couldn't find PCI device"));
 523
 524         return PVRSRV_ERROR_GENERIC;
 525 }
 526
 527 static IMG_UINT32 GetPCIMemSpaceSize (IMG_UINT32 ui32BusNum, IMG_UINT32 ui32DevNum, IMG_UINT32 ui32BarIndex, IMG_UINT32* pui32PCIMemSpaceSize)
 528 {
 529
 530         IMG_UINT32      ui32AddressRange;
 531         IMG_UINT32      ui32BarSave;
 532
 533         ui32BarSave = OSPCIReadDword (ui32BusNum, ui32DevNum, 0, ((4 + ui32BarIndex) * sizeof (IMG_UINT32)));
 534
 535         OSPCIWriteDword (ui32BusNum, ui32DevNum, 0, ((4 + ui32BarIndex) * sizeof (IMG_UINT32)), 0xFFFFFFFF);
 536
 537         ui32AddressRange = OSPCIReadDword (ui32BusNum, ui32DevNum, 0, ((4 + ui32BarIndex) * sizeof (IMG_UINT32)));
 538
 539         OSPCIWriteDword (ui32BusNum, ui32DevNum, 0, ((4 + ui32BarIndex) * sizeof (IMG_UINT32)), ui32BarSave);
 540
 541         *pui32PCIMemSpaceSize = (~(ui32AddressRange & 0xFFFFFFF0)) + 1;
 542         return PVRSRV_OK;
 543 }
 544 #endif
 545
 546
 547 #ifdef __linux__
 548 #define VERSION_STR_MAX_LEN_TEMPLATE "SGX revision = 000.000.000"
 549 static PVRSRV_ERROR SysCreateVersionString(SYS_DATA *psSysData)
 550 {
 551     IMG_UINT32 ui32SGXRevision = 0;
 552     IMG_UINT32 ui32MaxStrLen;
 553     PVRSRV_ERROR eError;
 554     IMG_INT32 i32Count;
 555     IMG_CHAR *pszVersionString;
 556
 557 #if !defined(NO_HARDWARE)
 558
 559     {
 560         IMG_VOID *pvSGXRegs;
 561
 562         pvSGXRegs = OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
 563                                                                                          gsSGXDeviceMap.ui32RegsSize,
 564                                                                                          PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
 565                                                                                          IMG_NULL);
 566
 567         if (pvSGXRegs != IMG_NULL)
 568         {
 569             ui32SGXRevision = OSReadHWReg(pvSGXRegs, EUR_CR_CORE_REVISION);
 570
 571              OSUnMapPhysToLin(pvSGXRegs,
 572                                                                                                 gsSGXDeviceMap.ui32RegsSize,
 573                                                                                                 PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
 574                                                                                                 IMG_NULL);
 575         }
 576         else
 577         {
 578              PVR_DPF((PVR_DBG_ERROR,"SysCreateVersionString: Couldn't map SGX registers"));
 579         }
 580     }
 581 #endif
 582
 583     ui32MaxStrLen = OSStringLength(VERSION_STR_MAX_LEN_TEMPLATE);
 584     eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
 585                           ui32MaxStrLen + 1,
 586                           (IMG_PVOID *)&pszVersionString,
 587                           IMG_NULL,
 588                                                   "Version String");
 589     if(eError != PVRSRV_OK)
 590     {
 591                 return PVRSRV_ERROR_GENERIC;
 592     }
 593
 594     i32Count = OSSNPrintf(pszVersionString, ui32MaxStrLen + 1,
 595                            "SGX revision = %u.%u.%u",
 596                            (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAJOR_MASK)
 597                             >> EUR_CR_CORE_REVISION_MAJOR_SHIFT),
 598                            (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MINOR_MASK)
 599                             >> EUR_CR_CORE_REVISION_MINOR_SHIFT),
 600                            (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAINTENANCE_MASK)
 601                             >> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)
 602                            );
 603     if(i32Count == -1)
 604     {
 605         ui32MaxStrLen = OSStringLength(VERSION_STR_MAX_LEN_TEMPLATE);
 606         OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
 607                     ui32MaxStrLen + 1,
 608                     pszVersionString,
 609                     IMG_NULL);
 610
 611                 return PVRSRV_ERROR_GENERIC;
 612     }
 613
 614     psSysData->pszVersionString = pszVersionString;
 615
 616     return PVRSRV_OK;
 617 }
 618
 619 static IMG_VOID SysFreeVersionString(SYS_DATA *psSysData)
 620 {
 621     if(psSysData->pszVersionString)
 622     {
 623         IMG_UINT32 ui32MaxStrLen;
 624         ui32MaxStrLen = OSStringLength(VERSION_STR_MAX_LEN_TEMPLATE);
 625         OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
 626                     ui32MaxStrLen+1,
 627                     psSysData->pszVersionString,
 628                     IMG_NULL);
 629                 psSysData->pszVersionString = NULL;
 630     }
 631 }
 632 #endif
 633 PVRSRV_ERROR SysInitialise(IMG_VOID)
 634 {
 635         IMG_UINT32                      i;
 636         PVRSRV_ERROR            eError;
 637         PVRSRV_DEVICE_NODE      *psDeviceNode;
 638         SGX_TIMING_INFORMATION* psTimingInfo;
 639
 640         PVR_DPF((PVR_DBG_MESSAGE,"SysInitialise"));
 641
 642         SysPlatformDetect();
 643
 644         gpsSysData = &gsSysData;
 645         OSMemSet(gpsSysData, 0, sizeof(SYS_DATA));
 646
 647         gpsSysData->pvSysSpecificData = &gsSysSpecificData;
 648         gsSysSpecificData.ui32SysSpecificData = 0;
 649 #ifdef  LDM_PCI
 650
 651         PVR_ASSERT(gpsPVRLDMDev != IMG_NULL);
 652         gsSysSpecificData.psPCIDev = gpsPVRLDMDev;
 653 #endif
 654
 655         eError = OSInitEnvData(&gpsSysData->pvEnvSpecificData);
 656         if (eError != PVRSRV_OK)
 657         {
 658                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to setup env structure"));
 659                 SysDeinitialise(gpsSysData);
 660                 gpsSysData = IMG_NULL;
 661                 return eError;
 662         }
 663
 664
 665         psTimingInfo = &gsSGXDeviceMap.sTimingInfo;
 666         psTimingInfo->ui32CoreClockSpeed = SYS_SGX_CLOCK_SPEED;
 667         psTimingInfo->ui32HWRecoveryFreq = SYS_SGX_HWRECOVERY_TIMEOUT_FREQ;
 668 #if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
 669         psTimingInfo->bEnableActivePM = IMG_TRUE;
 670 #else
 671         psTimingInfo->bEnableActivePM = IMG_FALSE;
 672 #endif
 673         psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
 674         psTimingInfo->ui32uKernelFreq = SYS_SGX_PDS_TIMER_FREQ;
 675
 676 #ifdef __linux__
 677         eError = PCIInitDev(gpsSysData);
 678         if (eError != PVRSRV_OK)
 679         {
 680                 SysDeinitialise(gpsSysData);
 681                 gpsSysData = IMG_NULL;
 682                 return eError;
 683         }
 684 #endif
 685
 686         gpsSysData->ui32NumDevices = SYS_DEVICE_COUNT;
 687
 688
 689         for(i=0; i<SYS_DEVICE_COUNT; i++)
 690         {
 691                 gpsSysData->sDeviceID[i].uiID = i;
 692                 gpsSysData->sDeviceID[i].bInUse = IMG_FALSE;
 693         }
 694
 695         gpsSysData->psDeviceNodeList = IMG_NULL;
 696         gpsSysData->psQueueList = IMG_NULL;
 697
 698         eError = SysInitialiseCommon(gpsSysData);
 699         if (eError != PVRSRV_OK)
 700         {
 701                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed in SysInitialiseCommon"));
 702                 SysDeinitialise(gpsSysData);
 703                 gpsSysData = IMG_NULL;
 704                 return eError;
 705         }
 706
 707
 708         eError = SysLocateDevices(gpsSysData);
 709         if (eError != PVRSRV_OK)
 710         {
 711                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to locate devices"));
 712                 SysDeinitialise(gpsSysData);
 713                 gpsSysData = IMG_NULL;
 714                 return eError;
 715         }
 716
 717
 718         eError = PVRSRVRegisterDevice(gpsSysData, SGXRegisterDevice,
 719                                                                   DEVICE_SGX_INTERRUPT, &gui32SGXDeviceID);
 720         if (eError != PVRSRV_OK)
 721         {
 722                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to register device!"));
 723                 SysDeinitialise(gpsSysData);
 724                 gpsSysData = IMG_NULL;
 725                 return eError;
 726         }
 727
 728 //#ifdef SUPPORT_MSVDX
 729         eError = PVRSRVRegisterDevice(gpsSysData, MSVDXRegisterDevice,
 730                                                                   DEVICE_MSVDX_INTERRUPT, &gui32MSVDXDeviceID);
 731         if (eError != PVRSRV_OK)
 732         {
 733                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to register device!"));
 734                 SysDeinitialise(gpsSysData);
 735                 gpsSysData = IMG_NULL;
 736                 return eError;
 737         }
 738 //#endif
 739
 740
 741         psDeviceNode = gpsSysData->psDeviceNodeList;
 742
 743         while(psDeviceNode)
 744         {
 745
 746                 switch(psDeviceNode->sDevId.eDeviceType)
 747                 {
 748                         case PVRSRV_DEVICE_TYPE_SGX:
 749                         {
 750                                 DEVICE_MEMORY_INFO *psDevMemoryInfo;
 751                                 DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
 752
 753
 754                                 psDeviceNode->psLocalDevMemArena = IMG_NULL;
 755
 756
 757                                 psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
 758                                 psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
 759
 760
 761                                 for(i=0; i<psDevMemoryInfo->ui32HeapCount; i++)
 762                                 {
 763                                         psDeviceMemoryHeap[i].ui32Attribs |= PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;
 764 #ifdef OEM_CUSTOMISE
 765
 766 #endif
 767                                 }
 768
 769                                 break;
 770                         }
 771
 772 //#ifdef SUPPORT_MSVDX
 773                         case PVRSRV_DEVICE_TYPE_MSVDX:
 774                         {
 775                                 DEVICE_MEMORY_INFO *psDevMemoryInfo;
 776                                 DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
 777
 778
 779                                 psDeviceNode->psLocalDevMemArena = IMG_NULL;
 780
 781
 782                                 psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
 783                                 psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
 784
 785
 786                                 for(i=0; i<psDevMemoryInfo->ui32HeapCount; i++)
 787                                 {
 788                                         psDeviceMemoryHeap[i].ui32Attribs |= PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;
 789 #ifdef OEM_CUSTOMISE
 790
 791 #endif
 792                                 }
 793                                 break;
 794                         }
 795 //#endif
 796                         default:
 797                         {
 798                                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to find SGX device node!"));
 799                                 return PVRSRV_ERROR_INIT_FAILURE;
 800                         }
 801                 }
 802
 803
 804                 psDeviceNode = psDeviceNode->psNext;
 805         }
 806
 807         PDUMPINIT();
 808         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PDUMP_INIT);
 809
 810
 811         eError = PVRSRVInitialiseDevice (gui32SGXDeviceID);
 812         if (eError != PVRSRV_OK)
 813         {
 814                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to initialise device!"));
 815                 SysDeinitialise(gpsSysData);
 816                 gpsSysData = IMG_NULL;
 817                 return eError;
 818         }
 819         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_SGX_INITIALISED);
 820
 821 //#ifdef SUPPORT_MSVDX
 822         eError = PVRSRVInitialiseDevice (gui32MSVDXDeviceID);
 823         if (eError != PVRSRV_OK)
 824         {
 825                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to initialise device!"));
 826                 SysDeinitialise(gpsSysData);
 827                 gpsSysData = IMG_NULL;
 828                 return eError;
 829         }
 830         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_MSVDX_INITIALISED);
 831 //#endif
 832
 833         return PVRSRV_OK;
 834 }
 835
 836
 837 static IMG_VOID SysEnableInterrupts(SYS_DATA *psSysData)
 838 {
 839 #if !defined(NO_HARDWARE)
 840         IMG_UINT32 ui32RegData;
 841         IMG_UINT32 ui32Mask;
 842
 843         ui32Mask = THALIA_MASK | MSVDX_MASK;
 844
 845         ui32RegData = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_IDENTITY_REG);
 846         OSWriteHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_IDENTITY_REG, ui32RegData | ui32Mask);
 847
 848
 849         ui32RegData = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_MASK_REG);
 850         OSWriteHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_MASK_REG, ui32RegData & (~ui32Mask));
 851
 852
 853         ui32RegData = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_ENABLE_REG);
 854         OSWriteHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_ENABLE_REG, ui32RegData | ui32Mask);
 855
 856         PVR_TRACE(("SysEnableInterrupts: Interrupts enabled"));
 857 #endif
 858         PVR_UNREFERENCED_PARAMETER(psSysData);
 859 }
 860
 861 static IMG_VOID SysDisableInterrupts(SYS_DATA *psSysData)
 862 {
 863 #if !defined(NO_HARDWARE)
 864         IMG_UINT32 ui32RegData;
 865         IMG_UINT32 ui32Mask;
 866
 867
 868         ui32Mask = THALIA_MASK | MSVDX_MASK;
 869
 870         ui32RegData = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_ENABLE_REG);
 871         OSWriteHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_ENABLE_REG, ui32RegData & (~ui32Mask));
 872
 873
 874         ui32RegData = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_MASK_REG);
 875         OSWriteHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_MASK_REG, ui32RegData | ui32Mask);
 876
 877         PVR_TRACE(("SysDisableInterrupts: Interrupts disabled"));
 878 #endif
 879         PVR_UNREFERENCED_PARAMETER(psSysData);
 880 }
 881
 882 IMG_VOID SysReEnableInterrupts(IMG_VOID)
 883 {
 884         SysEnableInterrupts(gpsSysData);
 885 }
 886
 887 PVRSRV_ERROR SysFinalise(IMG_VOID)
 888 {
 889         PVRSRV_ERROR eError = PVRSRV_OK;
 890
 891 #if defined(SYS_USING_INTERRUPTS)
 892         eError = OSInstallMISR(gpsSysData);
 893         if (eError != PVRSRV_OK)
 894         {
 895                 PVR_DPF((PVR_DBG_ERROR,"SysFinalise: OSInstallMISR failed"));
 896                 SysDeinitialise(gpsSysData);
 897                 gpsSysData = IMG_NULL;
 898                 return eError;
 899         }
 900         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_MISR_INSTALLED);
 901
 902         eError = OSInstallSystemLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ);
 903         if (eError != PVRSRV_OK)
 904         {
 905                 PVR_DPF((PVR_DBG_ERROR,"SysFinalise: OSInstallSystemLISR failed"));
 906                 SysDeinitialise(gpsSysData);
 907                 gpsSysData = IMG_NULL;
 908                 return eError;
 909         }
 910         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_LISR_INSTALLED);
 911 #endif
 912
 913         SysEnableInterrupts(gpsSysData);
 914         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_IRQ_ENABLED);
 915
 916 #ifdef  __linux__
 917
 918         eError = SysCreateVersionString(gpsSysData);
 919         if (eError != PVRSRV_OK)
 920         {
 921                 PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to create a system version string"));
 922         }
 923 #endif
 924
 925         return eError;
 926 }
 927
 928 PVRSRV_ERROR SysDeinitialise (SYS_DATA *psSysData)
 929 {
 930         PVRSRV_ERROR eError;
 931
 932         SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
 933
 934         if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_IRQ_ENABLED))
 935         {
 936                 SysDisableInterrupts(psSysData);
 937         }
 938
 939 #if defined(SYS_USING_INTERRUPTS)
 940         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_LISR_INSTALLED))
 941         {
 942                 eError = OSUninstallSystemLISR(psSysData);
 943                 if (eError != PVRSRV_OK)
 944                 {
 945                         PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallSystemLISR failed"));
 946                         return eError;
 947                 }
 948         }
 949
 950         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_MISR_INSTALLED))
 951         {
 952                 eError = OSUninstallMISR(psSysData);
 953                 if (eError != PVRSRV_OK)
 954                 {
 955                         PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallMISR failed"));
 956                         return eError;
 957                 }
 958         }
 959 #endif
 960 /* Commenting this out to clean up allocation made in SysInitialise */
 961 /*#if defined(SUPPORT_MSVDX)*/
 962         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_MSVDX_INITIALISED))
 963         {
 964
 965                 eError = PVRSRVDeinitialiseDevice(gui32MSVDXDeviceID);
 966                 if (eError != PVRSRV_OK)
 967                 {
 968                         PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
 969                         return eError;
 970                 }
 971         }
 972 /*#endif*/
 973
 974         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_SGX_INITIALISED))
 975         {
 976
 977                 eError = PVRSRVDeinitialiseDevice(gui32SGXDeviceID);
 978                 if (eError != PVRSRV_OK)
 979                 {
 980                         PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
 981                         return eError;
 982                 }
 983         }
 984
 985 #ifdef __linux__
 986         SysFreeVersionString(psSysData);
 987
 988         PCIDeInitDev(psSysData);
 989 #endif
 990
 991         eError = OSDeInitEnvData(psSysData->pvEnvSpecificData);
 992         if (eError != PVRSRV_OK)
 993         {
 994                 PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init env structure"));
 995                 return eError;
 996         }
 997
 998         SysDeinitialiseCommon(gpsSysData);
 999
1000 #if defined(NO_HARDWARE)
1001 #ifdef SUPPORT_MSVDX
1002         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_ALLOC_DUMMY_MSVDX_REGS))
1003         {
1004                 OSBaseFreeContigMemory(MSVDX_REG_SIZE, gsMSVDXRegsCPUVAddr, gsMSVDXDeviceMap.sRegsCpuPBase);
1005         }
1006 #endif
1007
1008         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_ALLOC_DUMMY_SGX_REGS))
1009         {
1010                 OSBaseFreeContigMemory(SGX_REG_SIZE, gsSGXRegsCPUVAddr, gsSGXDeviceMap.sRegsCpuPBase);
1011         }
1012 #endif
1013
1014 #if !defined(NO_HARDWARE)
1015
1016         OSUnMapPhysToLin(gsPoulsboRegsCPUVaddr,
1017                                                                                          REG_SIZE,
1018                                                                                          PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
1019                                                                                          IMG_NULL);
1020
1021 #if defined(MAP_UNUSED_MAPPINGS)
1022         OSUnMapPhysToLin(gsPoulsboDisplayRegsCPUVaddr,
1023                                                                                          DISPLAY_REG_SIZE,
1024                                                                                          PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
1025                                                                                          IMG_NULL);
1026 #endif
1027
1028 #endif
1029         if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_PDUMP_INIT))
1030         {
1031                 PDUMPDEINIT();
1032         }
1033
1034         gpsSysData = IMG_NULL;
1035
1036         return PVRSRV_OK;
1037 }
1038
1039
1040 IMG_UINT32 SysGetInterruptSource(SYS_DATA* psSysData,
1041                                                                  PVRSRV_DEVICE_NODE *psDeviceNode)
1042 {
1043 #if !defined(NO_HARDWARE)
1044         IMG_UINT32 ui32Devices = 0;
1045         IMG_UINT32 ui32Data, ui32DIMMask;
1046
1047         PVR_UNREFERENCED_PARAMETER(psSysData);
1048         PVR_UNREFERENCED_PARAMETER(psDeviceNode);
1049
1050
1051         ui32Data = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_IDENTITY_REG);
1052
1053         if (ui32Data & THALIA_MASK)
1054         {
1055                 ui32Devices |= DEVICE_SGX_INTERRUPT;
1056         }
1057
1058         if (ui32Data & MSVDX_MASK)
1059         {
1060                 ui32Devices |= DEVICE_MSVDX_INTERRUPT;
1061         }
1062
1063
1064         ui32DIMMask = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_ENABLE_REG);
1065         ui32DIMMask &= ~(THALIA_MASK | MSVDX_MASK);
1066
1067
1068         if (ui32Data & ui32DIMMask)
1069         {
1070                 ui32Devices |= DEVICE_DISP_INTERRUPT;
1071         }
1072
1073         return (ui32Devices);
1074 #else
1075         PVR_UNREFERENCED_PARAMETER(psSysData);
1076         PVR_UNREFERENCED_PARAMETER(psDeviceNode);
1077
1078         return 0;
1079 #endif
1080 }
1081
1082 IMG_VOID SysClearInterrupts(SYS_DATA* psSysData, IMG_UINT32 ui32ClearBits)
1083 {
1084 #if !defined(NO_HARDWARE)
1085         IMG_UINT32 ui32Data;
1086         IMG_UINT32 ui32Mask = 0;
1087
1088         PVR_UNREFERENCED_PARAMETER(psSysData);
1089
1090         ui32Data = OSReadHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_STATUS_REG);
1091
1092         if ((ui32ClearBits & DEVICE_SGX_INTERRUPT) &&
1093                 ((ui32Data & THALIA_MASK) == 0))
1094         {
1095                 ui32Mask |= THALIA_MASK;
1096         }
1097
1098         if ((ui32ClearBits & DEVICE_MSVDX_INTERRUPT) &&
1099                 ((ui32Data & MSVDX_MASK) == 0))
1100         {
1101                 ui32Mask |= MSVDX_MASK;
1102         }
1103
1104         if (ui32Mask)
1105         {
1106                 OSWriteHWReg(gsPoulsboRegsCPUVaddr, INTERRUPT_IDENTITY_REG, ui32Mask);
1107         }
1108 #else
1109         PVR_UNREFERENCED_PARAMETER(psSysData);
1110         PVR_UNREFERENCED_PARAMETER(ui32ClearBits);
1111 #endif
1112 }
1113
1114
1115
1116 PVRSRV_ERROR SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE eDeviceType,
1117                                                                         IMG_VOID **ppvDeviceMap)
1118 {
1119
1120         switch(eDeviceType)
1121         {
1122                 case PVRSRV_DEVICE_TYPE_SGX:
1123                 {
1124
1125                         *ppvDeviceMap = (IMG_VOID*)&gsSGXDeviceMap;
1126                         break;
1127                 }
1128 #ifdef SUPPORT_MSVDX
1129                 case PVRSRV_DEVICE_TYPE_MSVDX:
1130                 {
1131
1132                         *ppvDeviceMap = (IMG_VOID*)&gsMSVDXDeviceMap;
1133                         break;
1134                 }
1135 #endif
1136                 default:
1137                 {
1138                         PVR_DPF((PVR_DBG_ERROR,"SysGetDeviceMemoryMap: unsupported device type"));
1139                 }
1140         }
1141         return PVRSRV_OK;
1142 }
1143
1144
1145 IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE eDeviceType,
1146                                                                                 IMG_CPU_PHYADDR CpuPAddr)
1147 {
1148         IMG_DEV_PHYADDR DevPAddr;
1149
1150         PVR_UNREFERENCED_PARAMETER(eDeviceType);
1151
1152
1153         DevPAddr.uiAddr = CpuPAddr.uiAddr;
1154
1155         return DevPAddr;
1156 }
1157
1158
1159 IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr (IMG_SYS_PHYADDR sys_paddr)
1160 {
1161         IMG_CPU_PHYADDR cpu_paddr;
1162
1163
1164         cpu_paddr.uiAddr = sys_paddr.uiAddr;
1165         return cpu_paddr;
1166 }
1167
1168 IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr (IMG_CPU_PHYADDR cpu_paddr)
1169 {
1170         IMG_SYS_PHYADDR sys_paddr;
1171
1172
1173         sys_paddr.uiAddr = cpu_paddr.uiAddr;
1174         return sys_paddr;
1175 }
1176
1177
1178 IMG_DEV_PHYADDR SysSysPAddrToDevPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_SYS_PHYADDR SysPAddr)
1179 {
1180     IMG_DEV_PHYADDR DevPAddr;
1181
1182         PVR_UNREFERENCED_PARAMETER(eDeviceType);
1183
1184
1185     DevPAddr.uiAddr = SysPAddr.uiAddr;
1186
1187     return DevPAddr;
1188 }
1189
1190
1191 IMG_SYS_PHYADDR SysDevPAddrToSysPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_DEV_PHYADDR DevPAddr)
1192 {
1193     IMG_SYS_PHYADDR SysPAddr;
1194
1195         PVR_UNREFERENCED_PARAMETER(eDeviceType);
1196
1197
1198     SysPAddr.uiAddr = DevPAddr.uiAddr;
1199
1200     return SysPAddr;
1201 }
1202
1203
1204 IMG_VOID SysRegisterExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)
1205 {
1206         PVR_UNREFERENCED_PARAMETER(psDeviceNode);
1207 }
1208
1209
1210 IMG_VOID SysRemoveExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)
1211 {
1212         PVR_UNREFERENCED_PARAMETER(psDeviceNode);
1213 }
1214
1215 PVRSRV_ERROR SysOEMFunction (   IMG_UINT32      ui32ID,
1216                                                                 IMG_VOID        *pvIn,
1217                                                                 IMG_UINT32  ulInSize,
1218                                                                 IMG_VOID        *pvOut,
1219                                                                 IMG_UINT32      ulOutSize)
1220 {
1221         if (ulInSize || pvIn);
1222
1223         if ((ui32ID == OEM_GET_EXT_FUNCS) &&
1224                 (ulOutSize == sizeof(PVRSRV_DC_OEM_JTABLE)))
1225         {
1226                 PVRSRV_DC_OEM_JTABLE *psOEMJTable = (PVRSRV_DC_OEM_JTABLE*)pvOut;
1227                 psOEMJTable->pfnOEMBridgeDispatch = &PVRSRV_BridgeDispatchKM;
1228 #ifdef  __linux__
1229                 psOEMJTable->pfnOEMReadRegistryString  = IMG_NULL;
1230                 psOEMJTable->pfnOEMWriteRegistryString = IMG_NULL;
1231 #else
1232                 psOEMJTable->pfnOEMReadRegistryString  = IMG_NULL;
1233                 psOEMJTable->pfnOEMWriteRegistryString = IMG_NULL;
1234 #endif
1235                 return PVRSRV_OK;
1236         }
1237
1238         return PVRSRV_ERROR_INVALID_PARAMS;
1239 }
1240
1241
1242
1243 PVRSRV_ERROR SysSystemPrePowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
1244 {
1245         PVRSRV_ERROR eError= PVRSRV_OK;
1246
1247         if (eNewPowerState != gpsSysData->eCurrentPowerState)
1248         {
1249                 if ((eNewPowerState == PVRSRV_SYS_POWER_STATE_D3) &&
1250                         (gpsSysData->eCurrentPowerState < PVRSRV_SYS_POWER_STATE_D3))
1251                 {
1252
1253                         if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_IRQ_ENABLED))
1254                         {
1255                                 SysDisableInterrupts(gpsSysData);
1256
1257                                 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE);
1258                                 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_IRQ_ENABLED);
1259                         }
1260
1261 #if defined(SYS_USING_INTERRUPTS)
1262                         if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_LISR_INSTALLED))
1263                         {
1264                                 eError = OSUninstallSystemLISR(gpsSysData);
1265                                 if (eError != PVRSRV_OK)
1266                                 {
1267                                         PVR_DPF((PVR_DBG_ERROR,"SysSystemPrePowerState: OSUninstallSystemLISR failed (%d)", eError));
1268                                 }
1269                                 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
1270                                 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_LISR_INSTALLED);
1271                         }
1272 #endif
1273
1274
1275 #ifdef  __linux__
1276                         eError = OSPCISuspendDev(gsSysSpecificData.hSGXPCI);
1277                         if (eError != PVRSRV_OK)
1278                         {
1279                                 PVR_DPF((PVR_DBG_ERROR,"SysSystemPrePowerState: OSPCISuspendDev failed (%d)", eError));
1280                         }
1281 #endif
1282                 }
1283         }
1284
1285         return eError;
1286 }
1287
1288 PVRSRV_ERROR SysSystemPostPowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
1289 {
1290         PVRSRV_ERROR eError = PVRSRV_OK;
1291
1292         if (eNewPowerState != gpsSysData->eCurrentPowerState)
1293         {
1294                 if ((gpsSysData->eCurrentPowerState == PVRSRV_SYS_POWER_STATE_D3) &&
1295                         (eNewPowerState < PVRSRV_SYS_POWER_STATE_D3))
1296                 {
1297 #ifdef  __linux__
1298                         eError = OSPCIResumeDev(gsSysSpecificData.hSGXPCI);
1299                         if (eError != PVRSRV_OK)
1300                         {
1301                                 PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSPCIResumeDev failed (%d)", eError));
1302                         }
1303 #endif
1304
1305
1306 #if defined(SYS_USING_INTERRUPTS)
1307                         if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR))
1308                         {
1309                                 eError = OSInstallSystemLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ);
1310                                 if (eError != PVRSRV_OK)
1311                                 {
1312                                         PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSInstallSystemLISR failed to install ISR (%d)", eError));
1313                                 }
1314                                 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_LISR_INSTALLED);
1315                                 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
1316                         }
1317 #endif
1318
1319                         if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE))
1320                         {
1321                                 SysEnableInterrupts(gpsSysData);
1322
1323                                 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_IRQ_ENABLED);
1324                                 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE);
1325                         }
1326                 }
1327         }
1328         return eError;
1329 }
1330
1331
1332 PVRSRV_ERROR SysDevicePrePowerState(IMG_UINT32                          ui32DeviceIndex,
1333                                                                         PVRSRV_DEV_POWER_STATE  eNewPowerState,
1334                                                                         PVRSRV_DEV_POWER_STATE  eCurrentPowerState)
1335 {
1336         if (ui32DeviceIndex == gui32SGXDeviceID)
1337         {
1338                 if ((eNewPowerState != eCurrentPowerState) &&
1339                         (eNewPowerState == PVRSRV_DEV_POWER_STATE_OFF))
1340                 {
1341                         PVR_DPF((PVR_DBG_MESSAGE,"SysDevicePrePowerState: Remove SGX power"));
1342                 }
1343         }
1344
1345         return PVRSRV_OK;
1346 }
1347
1348
1349 PVRSRV_ERROR SysDevicePostPowerState(IMG_UINT32                         ui32DeviceIndex,
1350                                                                          PVRSRV_DEV_POWER_STATE eNewPowerState,
1351                                                                          PVRSRV_DEV_POWER_STATE eCurrentPowerState)
1352 {
1353         if (ui32DeviceIndex == gui32SGXDeviceID)
1354         {
1355                 if ((eNewPowerState != eCurrentPowerState) &&
1356                         (eCurrentPowerState == PVRSRV_DEV_POWER_STATE_OFF))
1357                 {
1358                         PVR_DPF((PVR_DBG_MESSAGE,"SysDevicePostPowerState: Restore SGX power"));
1359                 }
1360         }
1361
1362         return PVRSRV_OK;
1363 }
1364
1365
1366
1367