1 /**********************************************************************
3 * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
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.
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.
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.
18 * The full GNU General Public License is included in this distribution in
19 * the file called "COPYING".
21 * Contact Information:
22 * Imagination Technologies Ltd. <gpl-support@imgtec.com>
23 * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
25 ******************************************************************************/
27 #include <linux/platform_device.h>
29 #include "services_headers.h"
30 #include "kerneldisplay.h"
33 #include "pvr_pdump.h"
34 #include "sgxinfokm.h"
36 #include "sysconfig.h"
37 #include "syscommon.h"
38 #include "img_types.h"
40 #include "pvr_bridge_km.h"
42 struct SYS_DATA *gpsSysData;
43 static struct SYS_DATA gsSysData;
45 static struct SYS_SPECIFIC_DATA gsSysSpecificData;
46 struct SYS_SPECIFIC_DATA *gpsSysSpecificData;
48 static u32 gui32SGXDeviceID;
49 static struct SGX_DEVICE_MAP gsSGXDeviceMap;
50 static struct PVRSRV_DEVICE_NODE *gpsSGXDevNode;
52 #define DEVICE_SGX_INTERRUPT (1 << 0)
54 #if defined(NO_HARDWARE)
55 static void *gsSGXRegsCPUVAddr;
58 static void __iomem *ocp_base;
60 static enum PVRSRV_ERROR SysLocateDevices(struct SYS_DATA *psSysData)
62 #if defined(NO_HARDWARE)
63 enum PVRSRV_ERROR eError;
64 struct IMG_CPU_PHYADDR sCpuPAddr;
67 PVR_UNREFERENCED_PARAMETER(psSysData);
69 gsSGXDeviceMap.ui32Flags = 0x0;
71 #if defined(NO_HARDWARE)
73 eError = OSBaseAllocContigMemory(SYS_OMAP3430_SGX_REGS_SIZE,
74 &gsSGXRegsCPUVAddr, &sCpuPAddr);
75 if (eError != PVRSRV_OK)
77 gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;
78 gsSGXDeviceMap.sRegsSysPBase =
79 SysCpuPAddrToSysPAddr(gsSGXDeviceMap.sRegsCpuPBase);
80 gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;
82 gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;
84 OSMemSet(gsSGXRegsCPUVAddr, 0, SYS_OMAP3430_SGX_REGS_SIZE);
86 gsSGXDeviceMap.ui32IRQ = 0;
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;
96 gsSGXDeviceMap.ui32IRQ = SYS_OMAP3430_SGX_IRQ;
104 u32 sgx_get_rev(void)
107 * Ugly solution, used until we have proper per device instances
108 * passed to functions and get rid of most if not all globals.
110 struct SYS_SPECIFIC_DATA *sysd = gpsSysSpecificData;
112 static u32 rev = -1UL;
118 regs = OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
119 SYS_OMAP3430_SGX_REGS_SIZE,
120 PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY,
125 err = clk_enable(sysd->psSGX_FCK);
127 err = clk_enable(sysd->psSGX_ICK);
130 rev = OSReadHWReg(regs, EUR_CR_CORE_REVISION);
132 clk_disable(sysd->psSGX_ICK);
133 clk_disable(sysd->psSGX_FCK);
135 OSUnMapPhysToLin(regs, SYS_OMAP3430_SGX_REGS_SIZE,
136 PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY, NULL);
141 unsigned long sgx_get_max_freq(void)
143 struct SYS_SPECIFIC_DATA *sysd = gpsSysSpecificData;
147 if (sysd->sgx_fck_max)
148 return sysd->sgx_fck_max;
151 * In case there's no board specific setting for this, return
152 * some revision specific defaults.
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;
169 u32 sgx_get_rev(void)
174 unsigned long sgx_get_max_freq()
176 return SYS_SGX_MAX_FREQ_NO_HW;
181 bool sgx_is_530(void)
189 char *SysCreateVersionString(struct IMG_CPU_PHYADDR sRegRegion)
191 static char aszVersionString[100];
192 struct SYS_DATA *psSysData;
196 if (SysAcquireData(&psSysData) != PVRSRV_OK)
199 ui32SGXRevision = sgx_get_rev();
201 i32Count = OSSNPrintf(aszVersionString, 100,
202 "SGX revision = %u.%u.%u",
203 (unsigned)((ui32SGXRevision &
204 EUR_CR_CORE_REVISION_MAJOR_MASK)
205 >> EUR_CR_CORE_REVISION_MAJOR_SHIFT),
206 (unsigned)((ui32SGXRevision &
207 EUR_CR_CORE_REVISION_MINOR_MASK)
208 >> EUR_CR_CORE_REVISION_MINOR_SHIFT),
209 (unsigned)((ui32SGXRevision &
210 EUR_CR_CORE_REVISION_MAINTENANCE_MASK)
211 >> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)
217 return aszVersionString;
220 static int sgx_ocp_init(void)
222 struct IMG_SYS_PHYADDR sys_pbase;
223 struct IMG_CPU_PHYADDR cpu_pbase;
225 sys_pbase.uiAddr = SYS_OMAP3430_OCP_REGS_SYS_PHYS_BASE;
226 cpu_pbase = SysSysPAddrToCpuPAddr(sys_pbase);
228 ocp_base = OSMapPhysToLin(cpu_pbase, SYS_OMAP3430_OCP_REGS_SIZE,
229 PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY,
233 PVR_DPF(PVR_DBG_ERROR, "%s: Failed to map OCP registers",
241 static void sgx_ocp_cleanup(void)
243 OSUnMapPhysToLin(ocp_base, SYS_OMAP3430_OCP_REGS_SIZE,
244 PVRSRV_HAP_UNCACHED | PVRSRV_HAP_KERNEL_ONLY, NULL);
247 void sgx_ocp_write_reg(u32 reg, u32 val)
251 /* OCP offsets are based at EUR_CR_OCP_REVISION */
252 reg -= EUR_CR_OCP_REVISION;
253 OSWriteHWReg(ocp_base, reg, val);
256 enum PVRSRV_ERROR SysInitialise(struct platform_device *pdev)
259 enum PVRSRV_ERROR eError;
260 struct PVRSRV_DEVICE_NODE *psDeviceNode;
261 struct IMG_CPU_PHYADDR TimerRegPhysBase;
262 struct sgx_platform_data *spd;
264 gpsSysData = &gsSysData;
266 gpsSysSpecificData = &gsSysSpecificData;
268 gpsSysData->pvSysSpecificData = gpsSysSpecificData;
270 spd = pdev->dev.platform_data;
272 gpsSysSpecificData->sgx_fck_max = spd->fclock_max;
274 eError = OSInitEnvData(&gpsSysData->pvEnvSpecificData);
275 if (eError != PVRSRV_OK) {
276 PVR_DPF(PVR_DBG_ERROR,
277 "SysInitialise: Failed to setup env structure");
278 SysDeinitialise(gpsSysData);
282 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
283 SYS_SPECIFIC_DATA_ENABLE_ENVDATA);
285 gpsSysData->ui32NumDevices = SYS_DEVICE_COUNT;
287 for (i = 0; i < SYS_DEVICE_COUNT; i++) {
288 gpsSysData->sDeviceID[i].uiID = i;
289 gpsSysData->sDeviceID[i].bInUse = IMG_FALSE;
292 gpsSysData->psDeviceNodeList = NULL;
293 gpsSysData->psQueueList = NULL;
295 eError = SysInitialiseCommon(gpsSysData);
296 if (eError != PVRSRV_OK) {
297 PVR_DPF(PVR_DBG_ERROR,
298 "SysInitialise: Failed in SysInitialiseCommon");
299 SysDeinitialise(gpsSysData);
304 TimerRegPhysBase.uiAddr =
305 SYS_OMAP3430_GP11TIMER_PHYS_BASE + SYS_OMAP3430_GPTIMER_REGS;
306 gpsSysData->pvSOCTimerRegisterKM = NULL;
307 gpsSysData->hSOCTimerRegisterOSMemHandle = NULL;
308 eError = OSReservePhys(TimerRegPhysBase, 4,
309 PVRSRV_HAP_MULTI_PROCESS | PVRSRV_HAP_UNCACHED,
310 (void **)&gpsSysData->pvSOCTimerRegisterKM,
311 &gpsSysData->hSOCTimerRegisterOSMemHandle);
312 if (eError != PVRSRV_OK) {
313 PVR_DPF(PVR_DBG_ERROR, "%s: OSReservePhys failed");
314 SysDeinitialise(gpsSysData);
319 gpsSysSpecificData->ui32SrcClockDiv = 3;
321 eError = SysLocateDevices(gpsSysData);
322 if (eError != PVRSRV_OK) {
323 PVR_DPF(PVR_DBG_ERROR,
324 "SysInitialise: Failed to locate devices");
325 SysDeinitialise(gpsSysData);
329 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
330 SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV);
332 if (sgx_ocp_init() < 0) {
333 SysDeinitialise(gpsSysData);
336 return PVRSRV_ERROR_GENERIC;
339 eError = PVRSRVRegisterDevice(gpsSysData, SGXRegisterDevice,
340 DEVICE_SGX_INTERRUPT, &gui32SGXDeviceID);
341 if (eError != PVRSRV_OK) {
342 PVR_DPF(PVR_DBG_ERROR,
343 "SysInitialise: Failed to register device!");
344 SysDeinitialise(gpsSysData);
348 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
349 SYS_SPECIFIC_DATA_ENABLE_REGDEV);
351 psDeviceNode = gpsSysData->psDeviceNodeList;
352 while (psDeviceNode) {
353 switch (psDeviceNode->sDevId.eDeviceType) {
354 case PVRSRV_DEVICE_TYPE_SGX:
356 struct DEVICE_MEMORY_INFO *psDevMemoryInfo;
357 struct DEVICE_MEMORY_HEAP_INFO
360 psDeviceNode->psLocalDevMemArena = NULL;
362 psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
364 psDevMemoryInfo->psDeviceMemoryHeap;
366 for (i = 0; i < psDevMemoryInfo->ui32HeapCount;
368 psDeviceMemoryHeap[i].ui32Attribs |=
369 PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;
371 gpsSGXDevNode = psDeviceNode;
372 gsSysSpecificData.psSGXDevNode = psDeviceNode;
377 PVR_DPF(PVR_DBG_ERROR, "SysInitialise: "
378 "Failed to find SGX device node!");
379 return PVRSRV_ERROR_INIT_FAILURE;
382 psDeviceNode = psDeviceNode->psNext;
386 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
387 SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT);
389 eError = InitSystemClocks(gpsSysData);
390 if (eError != PVRSRV_OK) {
391 PVR_DPF(PVR_DBG_ERROR,
392 "SysInitialise: Failed to init system clocks (%d)",
394 SysDeinitialise(gpsSysData);
399 eError = EnableSystemClocks(gpsSysData);
400 if (eError != PVRSRV_OK) {
401 PVR_DPF(PVR_DBG_ERROR,
402 "SysInitialise: Failed to Enable system clocks (%d)",
404 SysDeinitialise(gpsSysData);
408 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
409 SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
411 eError = OSInitPerf(gpsSysData);
412 if (eError != PVRSRV_OK) {
413 PVR_DPF(PVR_DBG_ERROR,
414 "SysInitialise: Failed to init DVFS (%d)", eError);
415 SysDeinitialise(gpsSysData);
419 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
420 SYS_SPECIFIC_DATA_ENABLE_PERF);
422 eError = EnableSGXClocks(gpsSysData);
423 if (eError != PVRSRV_OK) {
424 PVR_DPF(PVR_DBG_ERROR,
425 "SysInitialise: Failed to Enable SGX clocks (%d)",
427 SysDeinitialise(gpsSysData);
432 eError = PVRSRVInitialiseDevice(gui32SGXDeviceID);
433 if (eError != PVRSRV_OK) {
434 PVR_DPF(PVR_DBG_ERROR,
435 "SysInitialise: Failed to initialise device!");
436 SysDeinitialise(gpsSysData);
440 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
441 SYS_SPECIFIC_DATA_ENABLE_INITDEV);
443 gpsSysData->pszVersionString =
444 SysCreateVersionString(gsSGXDeviceMap.sRegsCpuPBase);
445 if (!gpsSysData->pszVersionString)
446 PVR_DPF(PVR_DBG_ERROR,
447 "SysFinalise: Failed to create a system version string");
449 PVR_DPF(PVR_DBG_WARNING, "SysFinalise: Version string: %s",
450 gpsSysData->pszVersionString);
452 DisableSGXClocks(gpsSysData);
457 enum PVRSRV_ERROR SysFinalise(void)
459 enum PVRSRV_ERROR eError = PVRSRV_OK;
461 eError = EnableSGXClocks(gpsSysData);
462 if (eError != PVRSRV_OK) {
463 PVR_DPF(PVR_DBG_ERROR,
464 "SysInitialise: Failed to Enable SGX clocks (%d)",
466 SysDeinitialise(gpsSysData);
472 eError = OSInstallMISR(gpsSysData);
473 if (eError != PVRSRV_OK) {
474 PVR_DPF(PVR_DBG_ERROR, "SysFinalise: Failed to install MISR");
475 SysDeinitialise(gpsSysData);
479 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
480 SYS_SPECIFIC_DATA_ENABLE_MISR);
483 OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR",
485 if (eError != PVRSRV_OK) {
486 PVR_DPF(PVR_DBG_ERROR, "SysFinalise: Failed to install ISR");
487 SysDeinitialise(gpsSysData);
491 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
492 SYS_SPECIFIC_DATA_ENABLE_LISR);
494 DisableSGXClocks(gpsSysData);
496 gpsSysSpecificData->bSGXInitComplete = IMG_TRUE;
501 enum PVRSRV_ERROR SysDeinitialise(struct SYS_DATA *psSysData)
503 enum PVRSRV_ERROR eError;
505 if (SYS_SPECIFIC_DATA_TEST
506 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR)) {
507 eError = OSUninstallDeviceLISR(psSysData);
508 if (eError != PVRSRV_OK) {
509 PVR_DPF(PVR_DBG_ERROR, "SysDeinitialise: "
510 "OSUninstallDeviceLISR failed");
515 if (SYS_SPECIFIC_DATA_TEST
516 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR)) {
517 eError = OSUninstallMISR(psSysData);
518 if (eError != PVRSRV_OK) {
519 PVR_DPF(PVR_DBG_ERROR, "SysDeinitialise: "
520 "OSUninstallMISR failed");
525 if (SYS_SPECIFIC_DATA_TEST
526 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV)) {
527 PVR_ASSERT(SYS_SPECIFIC_DATA_TEST
529 SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS));
531 eError = EnableSGXClocks(gpsSysData);
532 if (eError != PVRSRV_OK) {
533 PVR_DPF(PVR_DBG_ERROR,
534 "SysDeinitialise: EnableSGXClocks failed");
538 eError = PVRSRVDeinitialiseDevice(gui32SGXDeviceID);
540 DisableSGXClocks(gpsSysData);
542 if (eError != PVRSRV_OK) {
543 PVR_DPF(PVR_DBG_ERROR, "SysDeinitialise: "
544 "failed to de-init the device");
549 if (SYS_SPECIFIC_DATA_TEST
550 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
551 DisableSystemClocks(gpsSysData);
553 CleanupSystemClocks(gpsSysData);
555 if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData,
556 SYS_SPECIFIC_DATA_ENABLE_PERF)) {
557 eError = OSCleanupPerf(psSysData);
558 if (eError != PVRSRV_OK) {
559 PVR_DPF(PVR_DBG_ERROR,
560 "SysDeinitialise: OSCleanupDvfs failed");
567 if (SYS_SPECIFIC_DATA_TEST
568 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA)) {
569 eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);
570 if (eError != PVRSRV_OK) {
571 PVR_DPF(PVR_DBG_ERROR,
572 "SysDeinitialise: failed to de-init env structure");
577 if (gpsSysData->pvSOCTimerRegisterKM)
578 OSUnReservePhys(gpsSysData->pvSOCTimerRegisterKM, 4,
579 PVRSRV_HAP_MULTI_PROCESS | PVRSRV_HAP_UNCACHED,
580 gpsSysData->hSOCTimerRegisterOSMemHandle);
582 SysDeinitialiseCommon(gpsSysData);
584 #if defined(NO_HARDWARE)
585 if (SYS_SPECIFIC_DATA_TEST
586 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV))
588 OSBaseFreeContigMemory(SYS_OMAP3430_SGX_REGS_SIZE,
590 gsSGXDeviceMap.sRegsCpuPBase);
593 if (SYS_SPECIFIC_DATA_TEST
594 (gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT))
597 gpsSysSpecificData->ui32SysSpecificData = 0;
598 gpsSysSpecificData->bSGXInitComplete = IMG_FALSE;
605 enum PVRSRV_ERROR SysGetDeviceMemoryMap(enum PVRSRV_DEVICE_TYPE eDeviceType,
608 switch (eDeviceType) {
609 case PVRSRV_DEVICE_TYPE_SGX:
610 *ppvDeviceMap = (void *) &gsSGXDeviceMap;
613 PVR_DPF(PVR_DBG_ERROR, "SysGetDeviceMemoryMap: "
614 "unsupported device type");
619 struct IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr(
620 enum PVRSRV_DEVICE_TYPE eDeviceType,
621 struct IMG_CPU_PHYADDR CpuPAddr)
623 struct IMG_DEV_PHYADDR DevPAddr;
625 PVR_UNREFERENCED_PARAMETER(eDeviceType);
627 DevPAddr.uiAddr = CpuPAddr.uiAddr;
632 struct IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr(struct IMG_SYS_PHYADDR sys_paddr)
634 struct IMG_CPU_PHYADDR cpu_paddr;
636 cpu_paddr.uiAddr = sys_paddr.uiAddr;
640 struct IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr(struct IMG_CPU_PHYADDR cpu_paddr)
642 struct IMG_SYS_PHYADDR sys_paddr;
644 sys_paddr.uiAddr = cpu_paddr.uiAddr;
648 struct IMG_DEV_PHYADDR SysSysPAddrToDevPAddr(
649 enum PVRSRV_DEVICE_TYPE eDeviceType,
650 struct IMG_SYS_PHYADDR SysPAddr)
652 struct IMG_DEV_PHYADDR DevPAddr;
654 PVR_UNREFERENCED_PARAMETER(eDeviceType);
656 DevPAddr.uiAddr = SysPAddr.uiAddr;
661 struct IMG_SYS_PHYADDR SysDevPAddrToSysPAddr(
662 enum PVRSRV_DEVICE_TYPE eDeviceType,
663 struct IMG_DEV_PHYADDR DevPAddr)
665 struct IMG_SYS_PHYADDR SysPAddr;
667 PVR_UNREFERENCED_PARAMETER(eDeviceType);
669 SysPAddr.uiAddr = DevPAddr.uiAddr;
674 void SysRegisterExternalDevice(struct PVRSRV_DEVICE_NODE *psDeviceNode)
676 PVR_UNREFERENCED_PARAMETER(psDeviceNode);
679 void SysRemoveExternalDevice(struct PVRSRV_DEVICE_NODE *psDeviceNode)
681 PVR_UNREFERENCED_PARAMETER(psDeviceNode);
684 u32 SysGetInterruptSource(struct SYS_DATA *psSysData,
685 struct PVRSRV_DEVICE_NODE *psDeviceNode)
687 PVR_UNREFERENCED_PARAMETER(psSysData);
688 #if defined(NO_HARDWARE)
693 return psDeviceNode->ui32SOCInterruptBit;
697 void SysClearInterrupts(struct SYS_DATA *psSysData, u32 ui32ClearBits)
699 PVR_UNREFERENCED_PARAMETER(psSysData);
700 PVR_UNREFERENCED_PARAMETER(ui32ClearBits);
702 OSReadHWReg(((struct PVRSRV_SGXDEV_INFO *)gpsSGXDevNode->pvDevice)->
703 pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR);
706 enum PVRSRV_ERROR SysSystemPrePowerState(enum PVR_POWER_STATE eNewPowerState)
708 enum PVRSRV_ERROR eError = PVRSRV_OK;
710 if (eNewPowerState == PVRSRV_POWER_STATE_D3) {
711 PVR_TRACE("SysSystemPrePowerState: Entering state D3");
713 if (SYS_SPECIFIC_DATA_TEST
714 (&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR)) {
715 eError = OSUninstallDeviceLISR(gpsSysData);
716 if (eError != PVRSRV_OK) {
717 PVR_DPF(PVR_DBG_ERROR,
718 "SysSystemPrePowerState: "
719 "OSUninstallDeviceLISR failed "
724 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
725 SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
726 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
727 SYS_SPECIFIC_DATA_ENABLE_LISR);
730 if (SYS_SPECIFIC_DATA_TEST
731 (&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS)) {
732 DisableSystemClocks(gpsSysData);
734 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
735 SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
736 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
737 SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
744 enum PVRSRV_ERROR SysSystemPostPowerState(enum PVR_POWER_STATE eNewPowerState)
746 enum PVRSRV_ERROR eError = PVRSRV_OK;
748 if (eNewPowerState == PVRSRV_POWER_STATE_D0) {
749 PVR_TRACE("SysSystemPostPowerState: Entering state D0");
751 if (SYS_SPECIFIC_DATA_TEST
753 SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS)) {
754 eError = EnableSystemClocks(gpsSysData);
755 if (eError != PVRSRV_OK) {
756 PVR_DPF(PVR_DBG_ERROR,
757 "SysSystemPostPowerState: "
758 "EnableSystemClocks failed (%d)",
762 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
763 SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
764 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
765 SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
767 if (SYS_SPECIFIC_DATA_TEST
768 (&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR)) {
770 OSInstallDeviceLISR(gpsSysData,
771 gsSGXDeviceMap.ui32IRQ,
772 "SGX ISR", gpsSGXDevNode);
773 if (eError != PVRSRV_OK) {
774 PVR_DPF(PVR_DBG_ERROR,
775 "SysSystemPostPowerState: "
776 "OSInstallDeviceLISR failed "
777 "to install ISR (%d)",
781 SYS_SPECIFIC_DATA_SET(&gsSysSpecificData,
782 SYS_SPECIFIC_DATA_ENABLE_LISR);
783 SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData,
784 SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
790 enum PVRSRV_ERROR SysDevicePrePowerState(u32 ui32DeviceIndex,
791 enum PVR_POWER_STATE eNewPowerState,
792 enum PVR_POWER_STATE eCurrentPowerState)
794 PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);
796 if (ui32DeviceIndex != gui32SGXDeviceID)
798 if (eNewPowerState == PVRSRV_POWER_STATE_D3) {
799 PVR_DPF(PVR_DBG_MESSAGE,
800 "SysDevicePrePowerState: SGX Entering state D3");
801 DisableSGXClocks(gpsSysData);
806 enum PVRSRV_ERROR SysDevicePostPowerState(u32 ui32DeviceIndex,
807 enum PVR_POWER_STATE eNewPowerState,
808 enum PVR_POWER_STATE eCurrentPowerState)
810 enum PVRSRV_ERROR eError = PVRSRV_OK;
812 PVR_UNREFERENCED_PARAMETER(eNewPowerState);
814 if (ui32DeviceIndex != gui32SGXDeviceID)
816 if (eCurrentPowerState == PVRSRV_POWER_STATE_D3) {
817 PVR_DPF(PVR_DBG_MESSAGE,
818 "SysDevicePostPowerState: SGX Leaving state D3");
819 eError = EnableSGXClocks(gpsSysData);
825 enum PVRSRV_ERROR SysOEMFunction(u32 ui32ID, void *pvIn, u32 ulInSize,
826 void *pvOut, u32 ulOutSize)
828 PVR_UNREFERENCED_PARAMETER(ui32ID);
829 PVR_UNREFERENCED_PARAMETER(pvIn);
830 PVR_UNREFERENCED_PARAMETER(ulInSize);
831 PVR_UNREFERENCED_PARAMETER(pvOut);
832 PVR_UNREFERENCED_PARAMETER(ulOutSize);
834 if ((ui32ID == OEM_GET_EXT_FUNCS) &&
835 (ulOutSize == sizeof(struct PVRSRV_DC_OEM_JTABLE))) {
837 struct PVRSRV_DC_OEM_JTABLE *psOEMJTable =
838 (struct PVRSRV_DC_OEM_JTABLE *)pvOut;
839 psOEMJTable->pfnOEMBridgeDispatch = &PVRSRV_BridgeDispatchKM;
843 return PVRSRV_ERROR_INVALID_PARAMS;