pvr/sysconfig.c

   1 /**********************************************************************
   2  *
   3  * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful but, except
  10  * as otherwise stated in writing, without any warranty; without even the
  11  * implied warranty of merchantability or fitness for a particular purpose.
  12  * See the GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * The full GNU General Public License is included in this distribution in
  19  * the file called "COPYING".
  20  *
  21  * Contact Information:
  22  * Imagination Technologies Ltd. <gpl-support@imgtec.com>
  23  * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
  24  *
  25  ******************************************************************************/
  26
  27 #include <linux/platform_device.h>
  28
  29 #include "services_headers.h"
  30 #include "kerneldisplay.h"
  31 #include "oemfuncs.h"
  32 #include "sgxinfo.h"
  33 #include "pvr_pdump.h"
  34 #include "sgxinfokm.h"
  35 #include "syslocal.h"
  36 #include "sysconfig.h"
  37 #include "syscommon.h"
  38 #include "img_types.h"
  39 #include "ocpdefs.h"
  40 #include "pvr_bridge_km.h"
  41
  42 struct SYS_DATA *gpsSysData;
  43 static struct SYS_DATA gsSysData;
  44
  45 static struct SYS_SPECIFIC_DATA gsSysSpecificData;
  46 struct SYS_SPECIFIC_DATA *gpsSysSpecificData;
  47
  48 static u32 gui32SGXDeviceID;
  49 static struct SGX_DEVICE_MAP gsSGXDeviceMap;
  50 static struct PVRSRV_DEVICE_NODE *gpsSGXDevNode;
  51
  52 #define DEVICE_SGX_INTERRUPT    (1 << 0)
  53
  54 #if defined(NO_HARDWARE)
  55 static void *gsSGXRegsCPUVAddr;
  56 #endif
  57
  58 static void __iomem *ocp_base;
  59
  60 static enum PVRSRV_ERROR SysLocateDevices(struct SYS_DATA *psSysData)
  61 {
  62 #if defined(NO_HARDWARE)
  63         enum PVRSRV_ERROR eError;
  64         struct IMG_CPU_PHYADDR sCpuPAddr;
  65 #endif
  66
  67         PVR_UNREFERENCED_PARAMETER(psSysData);
  68
  69         gsSGXDeviceMap.ui32Flags = 0x0;
  70
  71 #if defined(NO_HARDWARE)
  72
  73         eError = OSBaseAllocContigMemory(SYS_OMAP3430_SGX_REGS_SIZE,
  74                                          &gsSGXRegsCPUVAddr, &sCpuPAddr);
  75         if (eError != PVRSRV_OK)
  76                 return eError;
  77         gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;
  78         gsSGXDeviceMap.sRegsSysPBase =
  79             SysCpuPAddrToSysPAddr(gsSGXDeviceMap.sRegsCpuPBase);
  80         gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;
  81
  82         gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;
  83
  84         OSMemSet(gsSGXRegsCPUVAddr, 0, SYS_OMAP3430_SGX_REGS_SIZE);
  85
  86         gsSGXDeviceMap.ui32IRQ = 0;
  87
  88 #else
  89
  90         gsSGXDeviceMap.sRegsSysPBase.uiAddr =
  91             SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE;
  92         gsSGXDeviceMap.sRegsCpuPBase =
  93             SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sRegsSysPBase);
  94         gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;
  95
  96         gsSGXDeviceMap.ui32IRQ = SYS_OMAP3430_SGX_IRQ;
  97
  98 #endif
  99
 100         return PVRSRV_OK;
 101 }
 102
 103 #ifndef NO_HARDWARE
 104 u32 sgx_get_rev(void)
 105 {
 106         /*
 107          * Ugly solution, used until we have proper per device instances
 108          * passed to functions and get rid of most if not all globals.
 109          */
 110         struct SYS_SPECIFIC_DATA *sysd = gpsSysSpecificData;
 111         void __iomem *regs;
 112         static u32 rev = -1UL;
 113         int err;
 114
 115         if (rev != -1UL)
 116                 return rev;
 117
 118         regs = OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
 119                                SYS_OMAP3430_SGX_REGS_SIZE,
 120                                PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY,
 121                                NULL);
 122         if (!regs)
 123                 return 0;
 124
 125         err = clk_enable(sysd->psSGX_FCK);
 126         BUG_ON(err);
 127         err = clk_enable(sysd->psSGX_ICK);
 128         BUG_ON(err);
 129
 130         rev = OSReadHWReg(regs, EUR_CR_CORE_REVISION);
 131
 132         clk_disable(sysd->psSGX_ICK);
 133         clk_disable(sysd->psSGX_FCK);
 134
 135         OSUnMapPhysToLin(regs, SYS_OMAP3430_SGX_REGS_SIZE,
 136                          PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY, NULL);
 137
 138         return rev;
 139 }
 140
 141 unsigned long sgx_get_max_freq(void)
 142 {
 143         struct SYS_SPECIFIC_DATA *sysd = gpsSysSpecificData;
 144
 145         BUG_ON(!sysd);
 146
 147         if (sysd->sgx_fck_max)
 148                 return sysd->sgx_fck_max;
 149
 150         /*
 151          * In case there's no board specific setting for this, return
 152          * some revision specific defaults.
 153          */
 154         if (sgx_is_530()) {
 155                 switch (sgx_get_rev()) {
 156                 case EUR_CR_CORE_MAKE_REV(1, 2, 1):
 157                         return SYS_SGX_MAX_FREQ_530R121;
 158                 case EUR_CR_CORE_MAKE_REV(1, 2, 5):
 159                         return SYS_SGX_MAX_FREQ_530R125;
 160                 }
 161         }
 162         BUG();
 163 }
 164
 165 #else
 166
 167 u32 sgx_get_rev(void)
 168 {
 169         return 0;
 170 }
 171
 172 unsigned long sgx_get_max_freq()
 173 {
 174         return SYS_SGX_MAX_FREQ_NO_HW;
 175 }
 176
 177 #endif
 178
 179 bool sgx_is_530(void)
 180 {
 181 #ifdef SGX530
 182         return true;
 183 #endif
 184         return false;
 185 }
 186
 187 char *SysCreateVersionString(struct IMG_CPU_PHYADDR sRegRegion)
 188 {
 189         static char aszVersionString[100];
 190         struct SYS_DATA *psSysData;
 191         u32 ui32SGXRevision;
 192         s32 i32Count;
 193
 194         if (SysAcquireData(&psSysData) != PVRSRV_OK)
 195                 return NULL;
 196
 197         ui32SGXRevision = sgx_get_rev();
 198
 199         i32Count = OSSNPrintf(aszVersionString, 100,
 200                               "SGX revision = %u.%u.%u",
 201                               (unsigned)((ui32SGXRevision &
 202                                      EUR_CR_CORE_REVISION_MAJOR_MASK)
 203                                     >> EUR_CR_CORE_REVISION_MAJOR_SHIFT),
 204                               (unsigned)((ui32SGXRevision &
 205                                      EUR_CR_CORE_REVISION_MINOR_MASK)
 206                                     >> EUR_CR_CORE_REVISION_MINOR_SHIFT),
 207                               (unsigned)((ui32SGXRevision &
 208                                      EUR_CR_CORE_REVISION_MAINTENANCE_MASK)
 209                                     >> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)
 210             );
 211
 212         if (i32Count == -1)
 213                 return NULL;
 214
 215         return aszVersionString;
 216 }
 217
 218 static int sgx_ocp_init(void)
 219 {
 220         struct IMG_SYS_PHYADDR sys_pbase;
 221         struct IMG_CPU_PHYADDR cpu_pbase;
 222
 223         sys_pbase.uiAddr = SYS_OMAP3430_OCP_REGS_SYS_PHYS_BASE;
 224         cpu_pbase = SysSysPAddrToCpuPAddr(sys_pbase);
 225
 226         ocp_base = OSMapPhysToLin(cpu_pbase, SYS_OMAP3430_OCP_REGS_SIZE,
 227                                   PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY,
 228                                   NULL);
 229
 230         if (!ocp_base) {
 231                 PVR_DPF(PVR_DBG_ERROR, "%s: Failed to map OCP registers",
 232                         __func__);
 233                 return -ENOMEM;
 234         }
 235
 236         return 0;
 237 }
 238
 239 static void sgx_ocp_cleanup(void)
 240 {
 241         OSUnMapPhysToLin(ocp_base, SYS_OMAP3430_OCP_REGS_SIZE,
 242                          PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY, NULL);
 243 }
 244
 245 void sgx_ocp_write_reg(u32 reg, u32 val)
 246 {
 247         BUG_ON(!ocp_base);
 248
 249         /* OCP offsets are based at EUR_CR_OCP_REVISION */
 250         reg -= EUR_CR_OCP_REVISION;
 251         OSWriteHWReg(ocp_base, reg, val);
 252 }
 253
 254 enum PVRSRV_ERROR SysInitialise(struct platform_device *pdev)
 255 {
 256         u32 i;
 257         enum PVRSRV_ERROR eError;
 258         struct PVRSRV_DEVICE_NODE *psDeviceNode;
 259         struct IMG_CPU_PHYADDR TimerRegPhysBase;
 260         struct sgx_platform_data *spd;
 261
 262         gpsSysData = &gsSysData;
 263
 264         gpsSysSpecificData = &gsSysSpecificData;
 265
 266         gpsSysData->pvSysSpecificData = gpsSysSpecificData;
 267
 268         spd = pdev->dev.platform_data;
 269         if (spd)
 270                 gpsSysSpecificData->sgx_fck_max = spd->fclock_max;
 271
 272         eError = OSInitEnvData(&gpsSysData->pvEnvSpecificData);
 273         if (eError != PVRSRV_OK) {
 274                 PVR_DPF(PVR_DBG_ERROR,
 275                          "SysInitialise: Failed to setup env structure");
 276                 SysDeinitialise(gpsSysData);
 277                 gpsSysData = NULL;
 278                 return eError;
 279         }
 280         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 281                               SYS_SPECIFIC_DATA_ENABLE_ENVDATA);
 282
 283         gpsSysData->ui32NumDevices = SYS_DEVICE_COUNT;
 284
 285         for (i = 0; i < SYS_DEVICE_COUNT; i++) {
 286                 gpsSysData->sDeviceID[i].uiID = i;
 287                 gpsSysData->sDeviceID[i].bInUse = IMG_FALSE;
 288         }
 289
 290         gpsSysData->psDeviceNodeList = NULL;
 291         gpsSysData->psQueueList = NULL;
 292
 293         eError = SysInitialiseCommon(gpsSysData);
 294         if (eError != PVRSRV_OK) {
 295                 PVR_DPF(PVR_DBG_ERROR,
 296                          "SysInitialise: Failed in SysInitialiseCommon");
 297                 SysDeinitialise(gpsSysData);
 298                 gpsSysData = NULL;
 299                 return eError;
 300         }
 301
 302         TimerRegPhysBase.uiAddr =
 303             SYS_OMAP3430_GP11TIMER_PHYS_BASE + SYS_OMAP3430_GPTIMER_REGS;
 304         gpsSysData->pvSOCTimerRegisterKM = NULL;
 305         gpsSysData->hSOCTimerRegisterOSMemHandle = NULL;
 306         OSReservePhys(TimerRegPhysBase, 4,
 307                       PVRSRV_HAP_MULTI_PROCESS | PVRSRV_HAP_UNCACHED,
 308                       (void **)&gpsSysData->pvSOCTimerRegisterKM,
 309                       &gpsSysData->hSOCTimerRegisterOSMemHandle);
 310
 311         gpsSysSpecificData->ui32SrcClockDiv = 3;
 312
 313         eError = SysLocateDevices(gpsSysData);
 314         if (eError != PVRSRV_OK) {
 315                 PVR_DPF(PVR_DBG_ERROR,
 316                          "SysInitialise: Failed to locate devices");
 317                 SysDeinitialise(gpsSysData);
 318                 gpsSysData = NULL;
 319                 return eError;
 320         }
 321         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 322                               SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV);
 323
 324         if (sgx_ocp_init() < 0) {
 325                 SysDeinitialise(gpsSysData);
 326                 gpsSysData = NULL;
 327
 328                 return PVRSRV_ERROR_GENERIC;
 329         }
 330
 331         eError = PVRSRVRegisterDevice(gpsSysData, SGXRegisterDevice,
 332                                       DEVICE_SGX_INTERRUPT, &gui32SGXDeviceID);
 333         if (eError != PVRSRV_OK) {
 334                 PVR_DPF(PVR_DBG_ERROR,
 335                          "SysInitialise: Failed to register device!");
 336                 SysDeinitialise(gpsSysData);
 337                 gpsSysData = NULL;
 338                 return eError;
 339         }
 340         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 341                               SYS_SPECIFIC_DATA_ENABLE_REGDEV);
 342
 343         psDeviceNode = gpsSysData->psDeviceNodeList;
 344         while (psDeviceNode) {
 345                 switch (psDeviceNode->sDevId.eDeviceType) {
 346                 case PVRSRV_DEVICE_TYPE_SGX:
 347                         {
 348                                 struct DEVICE_MEMORY_INFO *psDevMemoryInfo;
 349                                 struct DEVICE_MEMORY_HEAP_INFO
 350                                                         *psDeviceMemoryHeap;
 351
 352                                 psDeviceNode->psLocalDevMemArena = NULL;
 353
 354                                 psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
 355                                 psDeviceMemoryHeap =
 356                                     psDevMemoryInfo->psDeviceMemoryHeap;
 357
 358                                 for (i = 0; i < psDevMemoryInfo->ui32HeapCount;
 359                                      i++)
 360                                         psDeviceMemoryHeap[i].ui32Attribs |=
 361                                            PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;
 362
 363                                 gpsSGXDevNode = psDeviceNode;
 364                                 gsSysSpecificData.psSGXDevNode = psDeviceNode;
 365
 366                                 break;
 367                         }
 368                 default:
 369                         PVR_DPF(PVR_DBG_ERROR, "SysInitialise: "
 370                                         "Failed to find SGX device node!");
 371                         return PVRSRV_ERROR_INIT_FAILURE;
 372                 }
 373
 374                 psDeviceNode = psDeviceNode->psNext;
 375         }
 376
 377         PDUMPINIT();
 378         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 379                               SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT);
 380
 381         eError = InitSystemClocks(gpsSysData);
 382         if (eError != PVRSRV_OK) {
 383                 PVR_DPF(PVR_DBG_ERROR,
 384                          "SysInitialise: Failed to init system clocks (%d)",
 385                          eError);
 386                 SysDeinitialise(gpsSysData);
 387                 gpsSysData = NULL;
 388                 return eError;
 389         }
 390
 391         eError = EnableSystemClocks(gpsSysData);
 392         if (eError != PVRSRV_OK) {
 393                 PVR_DPF(PVR_DBG_ERROR,
 394                          "SysInitialise: Failed to Enable system clocks (%d)",
 395                          eError);
 396                 SysDeinitialise(gpsSysData);
 397                 gpsSysData = NULL;
 398                 return eError;
 399         }
 400         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 401                               SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
 402
 403         eError = OSInitPerf(gpsSysData);
 404         if (eError != PVRSRV_OK) {
 405                 PVR_DPF(PVR_DBG_ERROR,
 406                          "SysInitialise: Failed to init DVFS (%d)", eError);
 407                 SysDeinitialise(gpsSysData);
 408                 gpsSysData = NULL;
 409                 return eError;
 410         }
 411         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 412                               SYS_SPECIFIC_DATA_ENABLE_PERF);
 413
 414         eError = EnableSGXClocks(gpsSysData);
 415         if (eError != PVRSRV_OK) {
 416                 PVR_DPF(PVR_DBG_ERROR,
 417                          "SysInitialise: Failed to Enable SGX clocks (%d)",
 418                          eError);
 419                 SysDeinitialise(gpsSysData);
 420                 gpsSysData = NULL;
 421                 return eError;
 422         }
 423
 424         eError = PVRSRVInitialiseDevice(gui32SGXDeviceID);
 425         if (eError != PVRSRV_OK) {
 426                 PVR_DPF(PVR_DBG_ERROR,
 427                          "SysInitialise: Failed to initialise device!");
 428                 SysDeinitialise(gpsSysData);
 429                 gpsSysData = NULL;
 430                 return eError;
 431         }
 432         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 433                               SYS_SPECIFIC_DATA_ENABLE_INITDEV);
 434
 435         gpsSysData->pszVersionString =
 436             SysCreateVersionString(gsSGXDeviceMap.sRegsCpuPBase);
 437         if (!gpsSysData->pszVersionString)
 438                 PVR_DPF(PVR_DBG_ERROR,
 439                 "SysFinalise: Failed to create a system version string");
 440         else
 441                 PVR_DPF(PVR_DBG_WARNING, "SysFinalise: Version string: %s",
 442                          gpsSysData->pszVersionString);
 443
 444         DisableSGXClocks(gpsSysData);
 445
 446         return PVRSRV_OK;
 447 }
 448
 449 enum PVRSRV_ERROR SysFinalise(void)
 450 {
 451         enum PVRSRV_ERROR eError = PVRSRV_OK;
 452
 453         eError = EnableSGXClocks(gpsSysData);
 454         if (eError != PVRSRV_OK) {
 455                 PVR_DPF(PVR_DBG_ERROR,
 456                          "SysInitialise: Failed to Enable SGX clocks (%d)",
 457                          eError);
 458                 SysDeinitialise(gpsSysData);
 459                 gpsSysData = NULL;
 460                 return eError;
 461         }
 462
 463
 464         eError = OSInstallMISR(gpsSysData);
 465         if (eError != PVRSRV_OK) {
 466                 PVR_DPF(PVR_DBG_ERROR, "SysFinalise: Failed to install MISR");
 467                 SysDeinitialise(gpsSysData);
 468                 gpsSysData = NULL;
 469                 return eError;
 470         }
 471         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 472                               SYS_SPECIFIC_DATA_ENABLE_MISR);
 473
 474         eError =
 475             OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR",
 476                                 gpsSGXDevNode);
 477         if (eError != PVRSRV_OK) {
 478                 PVR_DPF(PVR_DBG_ERROR, "SysFinalise: Failed to install ISR");
 479                 SysDeinitialise(gpsSysData);
 480                 gpsSysData = NULL;
 481                 return eError;
 482         }
 483         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 484                               SYS_SPECIFIC_DATA_ENABLE_LISR);
 485
 486         DisableSGXClocks(gpsSysData);
 487
 488         gpsSysSpecificData->bSGXInitComplete = IMG_TRUE;
 489
 490         return eError;
 491 }
 492
 493 enum PVRSRV_ERROR SysDeinitialise(struct SYS_DATA *psSysData)
 494 {
 495         enum PVRSRV_ERROR eError;
 496
 497         if (SYS_SPECIFIC_DATA_TEST
 498             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR)) {
 499                 eError = OSUninstallDeviceLISR(psSysData);
 500                 if (eError != PVRSRV_OK) {
 501                         PVR_DPF(PVR_DBG_ERROR, "SysDeinitialise: "
 502                                         "OSUninstallDeviceLISR failed");
 503                         return eError;
 504                 }
 505         }
 506
 507         if (SYS_SPECIFIC_DATA_TEST
 508             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR)) {
 509                 eError = OSUninstallMISR(psSysData);
 510                 if (eError != PVRSRV_OK) {
 511                         PVR_DPF(PVR_DBG_ERROR, "SysDeinitialise: "
 512                                                 "OSUninstallMISR failed");
 513                         return eError;
 514                 }
 515         }
 516
 517         if (SYS_SPECIFIC_DATA_TEST
 518             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV)) {
 519                 PVR_ASSERT(SYS_SPECIFIC_DATA_TEST
 520                            (gpsSysSpecificData,
 521                             SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS));
 522
 523                 eError = EnableSGXClocks(gpsSysData);
 524                 if (eError != PVRSRV_OK) {
 525                         PVR_DPF(PVR_DBG_ERROR,
 526                                  "SysDeinitialise: EnableSGXClocks failed");
 527                         return eError;
 528                 }
 529
 530                 eError = PVRSRVDeinitialiseDevice(gui32SGXDeviceID);
 531
 532                 DisableSGXClocks(gpsSysData);
 533
 534                 if (eError != PVRSRV_OK) {
 535                         PVR_DPF(PVR_DBG_ERROR, "SysDeinitialise: "
 536                                         "failed to de-init the device");
 537                         return eError;
 538                 }
 539         }
 540
 541         if (SYS_SPECIFIC_DATA_TEST
 542             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
 543                 DisableSystemClocks(gpsSysData);
 544
 545         CleanupSystemClocks(gpsSysData);
 546
 547         if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData,
 548                                    SYS_SPECIFIC_DATA_ENABLE_PERF)) {
 549                 eError = OSCleanupPerf(psSysData);
 550                 if (eError != PVRSRV_OK) {
 551                         PVR_DPF(PVR_DBG_ERROR,
 552                                  "SysDeinitialise: OSCleanupDvfs failed");
 553                         return eError;
 554                 }
 555         }
 556
 557         sgx_ocp_cleanup();
 558
 559         if (SYS_SPECIFIC_DATA_TEST
 560             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA)) {
 561                 eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);
 562                 if (eError != PVRSRV_OK) {
 563                         PVR_DPF(PVR_DBG_ERROR,
 564                         "SysDeinitialise: failed to de-init env structure");
 565                         return eError;
 566                 }
 567         }
 568
 569         if (gpsSysData->pvSOCTimerRegisterKM)
 570                 OSUnReservePhys(gpsSysData->pvSOCTimerRegisterKM, 4,
 571                                 PVRSRV_HAP_MULTI_PROCESS | PVRSRV_HAP_UNCACHED,
 572                                 gpsSysData->hSOCTimerRegisterOSMemHandle);
 573
 574         SysDeinitialiseCommon(gpsSysData);
 575
 576 #if defined(NO_HARDWARE)
 577         if (SYS_SPECIFIC_DATA_TEST
 578             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV))
 579
 580                 OSBaseFreeContigMemory(SYS_OMAP3430_SGX_REGS_SIZE,
 581                                        gsSGXRegsCPUVAddr,
 582                                        gsSGXDeviceMap.sRegsCpuPBase);
 583 #endif
 584
 585         if (SYS_SPECIFIC_DATA_TEST
 586             (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT))
 587                 PDUMPDEINIT();
 588
 589         gpsSysSpecificData->ui32SysSpecificData = 0;
 590         gpsSysSpecificData->bSGXInitComplete = IMG_FALSE;
 591
 592         gpsSysData = NULL;
 593
 594         return PVRSRV_OK;
 595 }
 596
 597 enum PVRSRV_ERROR SysGetDeviceMemoryMap(enum PVRSRV_DEVICE_TYPE eDeviceType,
 598                                    void **ppvDeviceMap)
 599 {
 600         switch (eDeviceType) {
 601         case PVRSRV_DEVICE_TYPE_SGX:
 602                 *ppvDeviceMap = (void *) &gsSGXDeviceMap;
 603                 break;
 604         default:
 605                 PVR_DPF(PVR_DBG_ERROR, "SysGetDeviceMemoryMap: "
 606                                         "unsupported device type");
 607         }
 608         return PVRSRV_OK;
 609 }
 610
 611 struct IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr(
 612                                 enum PVRSRV_DEVICE_TYPE eDeviceType,
 613                                 struct IMG_CPU_PHYADDR CpuPAddr)
 614 {
 615         struct IMG_DEV_PHYADDR DevPAddr;
 616
 617         PVR_UNREFERENCED_PARAMETER(eDeviceType);
 618
 619         DevPAddr.uiAddr = CpuPAddr.uiAddr;
 620
 621         return DevPAddr;
 622 }
 623
 624 struct IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr(struct IMG_SYS_PHYADDR sys_paddr)
 625 {
 626         struct IMG_CPU_PHYADDR cpu_paddr;
 627
 628         cpu_paddr.uiAddr = sys_paddr.uiAddr;
 629         return cpu_paddr;
 630 }
 631
 632 struct IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr(struct IMG_CPU_PHYADDR cpu_paddr)
 633 {
 634         struct IMG_SYS_PHYADDR sys_paddr;
 635
 636         sys_paddr.uiAddr = cpu_paddr.uiAddr;
 637         return sys_paddr;
 638 }
 639
 640 struct IMG_DEV_PHYADDR SysSysPAddrToDevPAddr(
 641                                 enum PVRSRV_DEVICE_TYPE eDeviceType,
 642                                 struct IMG_SYS_PHYADDR SysPAddr)
 643 {
 644         struct IMG_DEV_PHYADDR DevPAddr;
 645
 646         PVR_UNREFERENCED_PARAMETER(eDeviceType);
 647
 648         DevPAddr.uiAddr = SysPAddr.uiAddr;
 649
 650         return DevPAddr;
 651 }
 652
 653 struct IMG_SYS_PHYADDR SysDevPAddrToSysPAddr(
 654                                       enum PVRSRV_DEVICE_TYPE eDeviceType,
 655                                       struct IMG_DEV_PHYADDR DevPAddr)
 656 {
 657         struct IMG_SYS_PHYADDR SysPAddr;
 658
 659         PVR_UNREFERENCED_PARAMETER(eDeviceType);
 660
 661         SysPAddr.uiAddr = DevPAddr.uiAddr;
 662
 663         return SysPAddr;
 664 }
 665
 666 void SysRegisterExternalDevice(struct PVRSRV_DEVICE_NODE *psDeviceNode)
 667 {
 668         PVR_UNREFERENCED_PARAMETER(psDeviceNode);
 669 }
 670
 671 void SysRemoveExternalDevice(struct PVRSRV_DEVICE_NODE *psDeviceNode)
 672 {
 673         PVR_UNREFERENCED_PARAMETER(psDeviceNode);
 674 }
 675
 676 u32 SysGetInterruptSource(struct SYS_DATA *psSysData,
 677                                  struct PVRSRV_DEVICE_NODE *psDeviceNode)
 678 {
 679         PVR_UNREFERENCED_PARAMETER(psSysData);
 680 #if defined(NO_HARDWARE)
 681
 682         return 0xFFFFFFFF;
 683 #else
 684
 685         return psDeviceNode->ui32SOCInterruptBit;
 686 #endif
 687 }
 688
 689 void SysClearInterrupts(struct SYS_DATA *psSysData, u32 ui32ClearBits)
 690 {
 691         PVR_UNREFERENCED_PARAMETER(psSysData);
 692         PVR_UNREFERENCED_PARAMETER(ui32ClearBits);
 693
 694         OSReadHWReg(((struct PVRSRV_SGXDEV_INFO *)gpsSGXDevNode->pvDevice)->
 695                     pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR);
 696 }
 697
 698 enum PVRSRV_ERROR SysSystemPrePowerState(enum PVR_POWER_STATE eNewPowerState)
 699 {
 700         enum PVRSRV_ERROR eError = PVRSRV_OK;
 701
 702         if (eNewPowerState == PVRSRV_POWER_STATE_D3) {
 703                 PVR_TRACE("SysSystemPrePowerState: Entering state D3");
 704
 705                 if (SYS_SPECIFIC_DATA_TEST
 706                     (&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR)) {
 707                         eError = OSUninstallDeviceLISR(gpsSysData);
 708                         if (eError != PVRSRV_OK) {
 709                                 PVR_DPF(PVR_DBG_ERROR,
 710                                                 "SysSystemPrePowerState: "
 711                                                 "OSUninstallDeviceLISR failed "
 712                                                 "(%d)",
 713                                          eError);
 714                                 return eError;
 715                         }
 716                         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 717                                         SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
 718                         SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
 719                                         SYS_SPECIFIC_DATA_ENABLE_LISR);
 720                 }
 721
 722                 if (SYS_SPECIFIC_DATA_TEST
 723                     (&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS)) {
 724                         DisableSystemClocks(gpsSysData);
 725
 726                         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 727                                 SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
 728                         SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
 729                                 SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
 730                 }
 731         }
 732
 733         return eError;
 734 }
 735
 736 enum PVRSRV_ERROR SysSystemPostPowerState(enum PVR_POWER_STATE eNewPowerState)
 737 {
 738         enum PVRSRV_ERROR eError = PVRSRV_OK;
 739
 740         if (eNewPowerState == PVRSRV_POWER_STATE_D0) {
 741                 PVR_TRACE("SysSystemPostPowerState: Entering state D0");
 742
 743                 if (SYS_SPECIFIC_DATA_TEST
 744                     (&gsSysSpecificData,
 745                      SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS)) {
 746                         eError = EnableSystemClocks(gpsSysData);
 747                         if (eError != PVRSRV_OK) {
 748                                 PVR_DPF(PVR_DBG_ERROR,
 749                                         "SysSystemPostPowerState: "
 750                                         "EnableSystemClocks failed (%d)",
 751                                          eError);
 752                                 return eError;
 753                         }
 754                         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 755                                         SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
 756                         SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
 757                                         SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
 758                 }
 759                 if (SYS_SPECIFIC_DATA_TEST
 760                     (&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR)) {
 761                         eError =
 762                             OSInstallDeviceLISR(gpsSysData,
 763                                                 gsSGXDeviceMap.ui32IRQ,
 764                                                 "SGX ISR", gpsSGXDevNode);
 765                         if (eError != PVRSRV_OK) {
 766                                 PVR_DPF(PVR_DBG_ERROR,
 767                                                 "SysSystemPostPowerState: "
 768                                                 "OSInstallDeviceLISR failed "
 769                                                 "to install ISR (%d)",
 770                                          eError);
 771                                 return eError;
 772                         }
 773                         SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
 774                                 SYS_SPECIFIC_DATA_ENABLE_LISR);
 775                         SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
 776                                 SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
 777                 }
 778         }
 779         return eError;
 780 }
 781
 782 enum PVRSRV_ERROR SysDevicePrePowerState(u32 ui32DeviceIndex,
 783                                     enum PVR_POWER_STATE eNewPowerState,
 784                                     enum PVR_POWER_STATE eCurrentPowerState)
 785 {
 786         PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);
 787
 788         if (ui32DeviceIndex != gui32SGXDeviceID)
 789                 return PVRSRV_OK;
 790         if (eNewPowerState == PVRSRV_POWER_STATE_D3) {
 791                 PVR_DPF(PVR_DBG_MESSAGE,
 792                          "SysDevicePrePowerState: SGX Entering state D3");
 793                 DisableSGXClocks(gpsSysData);
 794         }
 795         return PVRSRV_OK;
 796 }
 797
 798 enum PVRSRV_ERROR SysDevicePostPowerState(u32 ui32DeviceIndex,
 799                                      enum PVR_POWER_STATE eNewPowerState,
 800                                      enum PVR_POWER_STATE eCurrentPowerState)
 801 {
 802         enum PVRSRV_ERROR eError = PVRSRV_OK;
 803
 804         PVR_UNREFERENCED_PARAMETER(eNewPowerState);
 805
 806         if (ui32DeviceIndex != gui32SGXDeviceID)
 807                 return eError;
 808         if (eCurrentPowerState == PVRSRV_POWER_STATE_D3) {
 809                 PVR_DPF(PVR_DBG_MESSAGE,
 810                          "SysDevicePostPowerState: SGX Leaving state D3");
 811                 eError = EnableSGXClocks(gpsSysData);
 812         }
 813
 814         return eError;
 815 }
 816
 817 enum PVRSRV_ERROR SysOEMFunction(u32 ui32ID, void *pvIn, u32 ulInSize,
 818                             void *pvOut, u32 ulOutSize)
 819 {
 820         PVR_UNREFERENCED_PARAMETER(ui32ID);
 821         PVR_UNREFERENCED_PARAMETER(pvIn);
 822         PVR_UNREFERENCED_PARAMETER(ulInSize);
 823         PVR_UNREFERENCED_PARAMETER(pvOut);
 824         PVR_UNREFERENCED_PARAMETER(ulOutSize);
 825
 826         if ((ui32ID == OEM_GET_EXT_FUNCS) &&
 827             (ulOutSize == sizeof(struct PVRSRV_DC_OEM_JTABLE))) {
 828
 829                 struct PVRSRV_DC_OEM_JTABLE *psOEMJTable =
 830                     (struct PVRSRV_DC_OEM_JTABLE *)pvOut;
 831                 psOEMJTable->pfnOEMBridgeDispatch = &PVRSRV_BridgeDispatchKM;
 832                 return PVRSRV_OK;
 833         }
 834
 835         return PVRSRV_ERROR_INVALID_PARAMS;
 836 }