libs/surfaceflinger/GPUHardware/GPUHardware.cpp - fp2-dev/platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "SurfaceFlinger"

 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <math.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>

 #include <cutils/log.h>
 #include <cutils/properties.h>

 #include <utils/MemoryDealer.h>
 #include <utils/MemoryBase.h>
 #include <utils/MemoryHeapPmem.h>
 #include <utils/MemoryHeapBase.h>
 #include <utils/IPCThreadState.h>
 #include <utils/StopWatch.h>

 #include <ui/ISurfaceComposer.h>

 #include "VRamHeap.h"
 #include "GPUHardware.h"

 #if HAVE_ANDROID_OS
 #include <linux/android_pmem.h>
 #endif

 #include "GPUHardware/GPUHardware.h"

 /*
  * This file manages the GPU if there is one. The intent is that this code
  * needs to be different for every devce. Currently there is no abstraction,
  * but in the long term, this code needs to be refactored so that API and
  * implementation are separated.
  *
  * In this particular implementation, the GPU, its memory and register are
  * managed here. Clients (such as OpenGL ES) request the GPU when then need
  * it and are given a revokable heap containing the registers on memory.
  *
  */

 namespace android {
 // ---------------------------------------------------------------------------

 // size reserved for GPU surfaces
 // 1200 KB fits exactly:
 //  - two 320*480 16-bits double-buffered surfaces
 //  - one 320*480 32-bits double-buffered surface
 //  - one 320*240 16-bits double-bufferd, 4x anti-aliased surface
 static const int GPU_RESERVED_SIZE  = 1200 * 1024;

 static const int GPUR_SIZE          = 1 * 1024 * 1024;

 // ---------------------------------------------------------------------------

 /*
  * GPUHandle is a special IMemory given to the client. It represents their
  * handle to the GPU. Once they give it up, they loose GPU access, or if
  * they explicitely revoke their acces through the binder code 1000.
  * In both cases, this triggers a callback to revoke()
  * first, and then actually powers down the chip.
  *
  * In the case of a misbehaving app, GPUHardware can ask for an immediate
  * release of the GPU to the target process which should answer by calling
  * code 1000 on GPUHandle. If it doesn't in a timely manner, the GPU will
  * be revoked from under their feet.
  *
  * We should never hold a strong reference on GPUHandle. In practice this
  * shouldn't be a big issue though because clients should use code 1000 and
  * not rely on the dtor being called.
  *
  */

 class GPUHandle : public BnMemory
 {
 public:
             GPUHandle(const sp<GPUHardware>& gpu, const sp<IMemoryHeap>& heap)
                 : mGPU(gpu), mClientHeap(heap) {
             }
     virtual ~GPUHandle();
     virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size) const;
     virtual status_t onTransact(
             uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
     void setOwner(int owner) { mOwner = owner; }
 private:
     void revokeNotification();
     wp<GPUHardware> mGPU;
     sp<IMemoryHeap> mClientHeap;
     int mOwner;
 };

 GPUHandle::~GPUHandle() {
     //LOGD("GPUHandle %p released, revoking GPU", this);
     revokeNotification();
 }

 void GPUHandle::revokeNotification()  {
     sp<GPUHardware> hw(mGPU.promote());
     if (hw != 0) {
         hw->revoke(mOwner);
     }
 }
 sp<IMemoryHeap> GPUHandle::getMemory(ssize_t* offset, size_t* size) const
 {
     if (offset) *offset = 0;
     if (size)   *size = mClientHeap !=0 ? mClientHeap->virtualSize() : 0;
     return mClientHeap;
 }
 status_t GPUHandle::onTransact(
         uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 {
     status_t err = BnMemory::onTransact(code, data, reply, flags);
     if (err == UNKNOWN_TRANSACTION && code == 1000) {
         int callingPid = IPCThreadState::self()->getCallingPid();
         //LOGD("pid %d voluntarily revoking gpu", callingPid);
         if (callingPid == mOwner) {
             revokeNotification();
             // we've revoked the GPU, don't do it again later when we
             // are destroyed.
             mGPU.clear();
         } else {
             LOGW("%d revoking someone else's gpu? (owner=%d)",
                     callingPid, mOwner);
         }
         err = NO_ERROR;
     }
     return err;
 }

 // ---------------------------------------------------------------------------

 class MemoryHeapRegs : public MemoryHeapPmem
 {
 public:
             MemoryHeapRegs(const wp<GPUHardware>& gpu, const sp<MemoryHeapBase>& heap);
     virtual ~MemoryHeapRegs();
     sp<IMemory> mapMemory(size_t offset, size_t size);
     virtual void revoke();
 private:
     wp<GPUHardware> mGPU;
 };

 MemoryHeapRegs::MemoryHeapRegs(const wp<GPUHardware>& gpu, const sp<MemoryHeapBase>& heap)
     :  MemoryHeapPmem(heap), mGPU(gpu)
 {
 #if HAVE_ANDROID_OS
     if (heapID()>0) {
         /* this is where the GPU is powered on and the registers are mapped
          * in the client */
         //LOGD("ioctl(HW3D_GRANT_GPU)");
         int err = ioctl(heapID(), HW3D_GRANT_GPU, base());
         if (err) {
             // it can happen if the master heap has been closed already
             // in which case the GPU already is revoked (app crash for
             // instance).
             //LOGW("HW3D_GRANT_GPU failed (%s), mFD=%d, base=%p",
             //        strerror(errno), heapID(), base());
         }
     }
 #endif
 }

 MemoryHeapRegs::~MemoryHeapRegs()
 {
 }

 sp<IMemory> MemoryHeapRegs::mapMemory(size_t offset, size_t size)
 {
     sp<GPUHandle> memory;
     sp<GPUHardware> gpu = mGPU.promote();
     if (heapID()>0 && gpu!=0)
         memory = new GPUHandle(gpu, this);
     return memory;
 }

 void MemoryHeapRegs::revoke()
 {
     MemoryHeapPmem::revoke();
 #if HAVE_ANDROID_OS
     if (heapID() > 0) {
         //LOGD("ioctl(HW3D_REVOKE_GPU)");
         int err = ioctl(heapID(), HW3D_REVOKE_GPU, base());
         LOGE_IF(err, "HW3D_REVOKE_GPU failed (%s), mFD=%d, base=%p",
                 strerror(errno), heapID(), base());
     }
 #endif
 }

 // ---------------------------------------------------------------------------

 class GPURegisterHeap : public PMemHeapInterface
 {
 public:
     GPURegisterHeap(const sp<GPUHardware>& gpu)
         : PMemHeapInterface("/dev/hw3d", GPUR_SIZE), mGPU(gpu)
     {
     }
     virtual ~GPURegisterHeap() {
     }
     virtual sp<MemoryHeapPmem> createClientHeap() {
         sp<MemoryHeapBase> parentHeap(this);
         return new MemoryHeapRegs(mGPU, parentHeap);
     }
 private:
     wp<GPUHardware> mGPU;
 };

 /*****************************************************************************/

 GPUHardware::GPUHardware()
     : mOwner(NO_OWNER)
 {
 }

 GPUHardware::~GPUHardware()
 {
 }

 sp<MemoryDealer> GPUHardware::request(int pid)
 {
     sp<MemoryDealer> dealer;

     LOGD("pid %d requesting gpu surface (current owner = %d)", pid, mOwner);

     const int self_pid = getpid();
     if (pid == self_pid) {
         // can't use GPU from surfaceflinger's process
         return dealer;
     }

     Mutex::Autolock _l(mLock);

     if (mOwner != pid) {
         // someone already has the gpu.
         takeBackGPULocked();

         // releaseLocked() should be a no-op most of the time
         releaseLocked();

         requestLocked();
     }

     dealer = mAllocator;
     mOwner = pid;
     if (dealer == 0) {
         mOwner = SURFACE_FAILED;
     }

     LOGD_IF(dealer!=0, "gpu surface granted to pid %d", mOwner);
     return dealer;
 }

 status_t GPUHardware::request(const sp<IGPUCallback>& callback,
         ISurfaceComposer::gpu_info_t* gpu)
 {
     sp<IMemory> gpuHandle;
     IPCThreadState* ipc = IPCThreadState::self();
     const int pid = ipc->getCallingPid();
     const int self_pid = getpid();

     LOGD("pid %d requesting gpu core (owner = %d)", pid, mOwner);

     if (pid == self_pid) {
         // can't use GPU from surfaceflinger's process
         return PERMISSION_DENIED;
     }

     Mutex::Autolock _l(mLock);
     if (mOwner != pid) {
         // someone already has the gpu.
         takeBackGPULocked();

         // releaseLocked() should be a no-op most of the time
         releaseLocked();

         requestLocked();
     }

     if (mHeapR.isValid()) {
         gpu->count = 2;
         gpu->regions[0].region = mHeap0.map(true);
         gpu->regions[0].reserved = mHeap0.reserved;
         gpu->regions[1].region = mHeap1.map(true);
         gpu->regions[1].reserved = mHeap1.reserved;
         gpu->regs = mHeapR.map();
         if (gpu->regs != 0) {
             static_cast< GPUHandle* >(gpu->regs.get())->setOwner(pid);
         }
         mCallback = callback;
         mOwner = pid;
         //LOGD("gpu core granted to pid %d, handle base=%p",
         //        mOwner, gpu->regs->pointer());
     } else {
         LOGW("couldn't grant gpu core to pid %d", pid);
     }

     return NO_ERROR;
 }

 void GPUHardware::revoke(int pid)
 {
     Mutex::Autolock _l(mLock);
     if (mOwner > 0) {
         if (pid != mOwner) {
             LOGW("GPU owned by %d, revoke from %d", mOwner, pid);
             return;
         }
         //LOGD("revoke pid=%d, owner=%d", pid, mOwner);
         // mOwner could be <0 if the same process acquired the GPU
         // several times without releasing it first.
         mCondition.signal();
         releaseLocked(true);
     }
 }

 status_t GPUHardware::friendlyRevoke()
 {
     Mutex::Autolock _l(mLock);
     takeBackGPULocked();
     //LOGD("friendlyRevoke owner=%d", mOwner);
     releaseLocked(true);
     return NO_ERROR;
 }

 void GPUHardware::takeBackGPULocked()
 {
     sp<IGPUCallback> callback = mCallback;
     mCallback.clear();
     if (callback != 0) {
         callback->gpuLost(); // one-way
         mCondition.waitRelative(mLock, ms2ns(250));
     }
 }

 void GPUHardware::requestLocked()
 {
     if (mAllocator == 0) {
         GPUPart* part = 0;
         sp<PMemHeap> surfaceHeap;
         if (mHeap1.promote() == false) {
             //LOGD("requestLocked: (1) creating new heap");
             mHeap1.set(new PMemHeap("/dev/pmem_gpu1", 0, GPU_RESERVED_SIZE));
         }
         if (mHeap1.isValid()) {
             //LOGD("requestLocked: (1) heap is valid");
             // NOTE: if GPU1 is available we use it for our surfaces
             // this could be device specific, so we should do something more
             // generic
             surfaceHeap = static_cast< PMemHeap* >( mHeap1.getHeap().get() );
             part = &mHeap1;
             if (mHeap0.promote() == false) {
                 //LOGD("requestLocked: (0) creating new heap");
                 mHeap0.set(new PMemHeap("/dev/pmem_gpu0"));
             }
         } else {
             //LOGD("requestLocked: (1) heap is not valid");
             // No GPU1, use GPU0 only
             if (mHeap0.promote() == false) {
                 //LOGD("requestLocked: (0) creating new heap");
                 mHeap0.set(new PMemHeap("/dev/pmem_gpu0", 0, GPU_RESERVED_SIZE));
             }
             if (mHeap0.isValid()) {
                 //LOGD("requestLocked: (0) heap is valid");
                 surfaceHeap = static_cast< PMemHeap* >( mHeap0.getHeap().get() );
                 part = &mHeap0;
             }
         }

         if (mHeap0.isValid() || mHeap1.isValid()) {
             if (mHeapR.promote() == false) {
                 //LOGD("requestLocked: (R) creating new register heap");
                 mHeapR.set(new GPURegisterHeap(this));
             }
         } else {
             // we got nothing...
             mHeap0.clear();
             mHeap1.clear();
         }

         if (mHeapR.isValid() == false) {
             //LOGD("requestLocked: (R) register heap not valid!!!");
             // damn, couldn't get the gpu registers!
             mHeap0.clear();
             mHeap1.clear();
             surfaceHeap.clear();
             part = NULL;
         }

         if (surfaceHeap != 0 && part && part->getClientHeap()!=0) {
             part->reserved = GPU_RESERVED_SIZE;
             part->surface = true;
             mAllocatorDebug = static_cast<SimpleBestFitAllocator*>(
                     surfaceHeap->getAllocator().get());
             mAllocator = new MemoryDealer(
                     part->getClientHeap(),
                     surfaceHeap->getAllocator());
         }
     }
 }

 void GPUHardware::releaseLocked(bool dispose)
 {
     /*
      * if dispose is set, we will force the destruction of the heap,
      * so it is given back to other systems, such as camera.
      * Otherwise, we'll keep a weak pointer to it, this way we might be able
      * to reuse it later if it's still around.
      */
     //LOGD("revoking gpu from pid %d", mOwner);
     mOwner = NO_OWNER;
     mAllocator.clear();
     mCallback.clear();

     /* if we're asked for a full revoke, dispose only of the heap
      * we're not using for surface (as we might need it while drawing) */
     mHeap0.release(mHeap0.surface ? false : dispose);
     mHeap1.release(mHeap1.surface ? false : dispose);
     mHeapR.release(false);
 }

 // ----------------------------------------------------------------------------
 // for debugging / testing ...

 sp<SimpleBestFitAllocator> GPUHardware::getAllocator() const {
     Mutex::Autolock _l(mLock);
     sp<SimpleBestFitAllocator> allocator = mAllocatorDebug.promote();
     return allocator;
 }

 void GPUHardware::unconditionalRevoke()
 {
     Mutex::Autolock _l(mLock);
     releaseLocked();
 }

 // ---------------------------------------------------------------------------


 GPUHardware::GPUPart::GPUPart()
     : surface(false), reserved(0)
 {
 }

 GPUHardware::GPUPart::~GPUPart() {
 }

 const sp<PMemHeapInterface>& GPUHardware::GPUPart::getHeap() const {
     return mHeap;
 }

 const sp<MemoryHeapPmem>& GPUHardware::GPUPart::getClientHeap() const {
     return mClientHeap;
 }

 bool GPUHardware::GPUPart::isValid() const {
     return ((mHeap!=0) && (mHeap->base() != MAP_FAILED));
 }

 void GPUHardware::GPUPart::clear()
 {
     mHeap.clear();
     mHeapWeak.clear();
     mClientHeap.clear();
     surface = false;
 }

 void GPUHardware::GPUPart::set(const sp<PMemHeapInterface>& heap)
 {
     mHeapWeak.clear();
     if (heap!=0 && heap->base() == MAP_FAILED) {
         mHeap.clear();
         mClientHeap.clear();
     } else {
         mHeap = heap;
         mClientHeap = mHeap->createClientHeap();
     }
 }

 bool GPUHardware::GPUPart::promote()
 {
     //LOGD("mHeapWeak=%p, mHeap=%p", mHeapWeak.unsafe_get(), mHeap.get());
     if (mHeap == 0) {
         mHeap = mHeapWeak.promote();
     }
     if (mHeap != 0) {
         if (mClientHeap != 0) {
             mClientHeap->revoke();
         }
         mClientHeap = mHeap->createClientHeap();
     }  else {
         surface = false;
     }
     return mHeap != 0;
 }

 sp<IMemory> GPUHardware::GPUPart::map(bool clear)
 {
     sp<IMemory> memory;
     if (mClientHeap != NULL) {
         memory = mClientHeap->mapMemory(0, mHeap->virtualSize());
         if (clear && memory!=0) {
             //StopWatch sw("memset");
             memset(memory->pointer(), 0, memory->size());
         }
     }
     return memory;
 }

 void GPUHardware::GPUPart::release(bool dispose)
 {
     if (mClientHeap != 0) {
         mClientHeap->revoke();
         mClientHeap.clear();
     }
     if (dispose) {
         if (mHeapWeak!=0 && mHeap==0) {
             mHeap = mHeapWeak.promote();
         }
         if (mHeap != 0) {
             mHeap->dispose();
             mHeapWeak.clear();
             mHeap.clear();
         } else {
             surface = false;
         }
     } else {
         if (mHeap != 0) {
             mHeapWeak = mHeap;
             mHeap.clear();
         }
     }
 }

 // ---------------------------------------------------------------------------
 }; // namespace android
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "SurfaceFlinger"

	#include <stdlib.h>
	#include <stdio.h>
	#include <stdint.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <math.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/ioctl.h>

	#include <cutils/log.h>
	#include <cutils/properties.h>

	#include <utils/MemoryDealer.h>
	#include <utils/MemoryBase.h>
	#include <utils/MemoryHeapPmem.h>
	#include <utils/MemoryHeapBase.h>
	#include <utils/IPCThreadState.h>
	#include <utils/StopWatch.h>

	#include <ui/ISurfaceComposer.h>

	#include "VRamHeap.h"
	#include "GPUHardware.h"

	#if HAVE_ANDROID_OS
	#include <linux/android_pmem.h>
	#endif

	#include "GPUHardware/GPUHardware.h"

	/*
	* This file manages the GPU if there is one. The intent is that this code
	* needs to be different for every devce. Currently there is no abstraction,
	* but in the long term, this code needs to be refactored so that API and
	* implementation are separated.
	*
	* In this particular implementation, the GPU, its memory and register are
	* managed here. Clients (such as OpenGL ES) request the GPU when then need
	* it and are given a revokable heap containing the registers on memory.
	*
	*/

	namespace android {
	// ---------------------------------------------------------------------------

	// size reserved for GPU surfaces
	// 1200 KB fits exactly:
	// - two 320*480 16-bits double-buffered surfaces
	// - one 320*480 32-bits double-buffered surface
	// - one 320*240 16-bits double-bufferd, 4x anti-aliased surface
	static const int GPU_RESERVED_SIZE = 1200 * 1024;

	static const int GPUR_SIZE = 1 * 1024 * 1024;

	// ---------------------------------------------------------------------------

	/*
	* GPUHandle is a special IMemory given to the client. It represents their
	* handle to the GPU. Once they give it up, they loose GPU access, or if
	* they explicitely revoke their acces through the binder code 1000.
	* In both cases, this triggers a callback to revoke()
	* first, and then actually powers down the chip.
	*
	* In the case of a misbehaving app, GPUHardware can ask for an immediate
	* release of the GPU to the target process which should answer by calling
	* code 1000 on GPUHandle. If it doesn't in a timely manner, the GPU will
	* be revoked from under their feet.
	*
	* We should never hold a strong reference on GPUHandle. In practice this
	* shouldn't be a big issue though because clients should use code 1000 and
	* not rely on the dtor being called.
	*
	*/

	class GPUHandle : public BnMemory
	{
	public:
	GPUHandle(const sp<GPUHardware>& gpu, const sp<IMemoryHeap>& heap)
	: mGPU(gpu), mClientHeap(heap) {
	}
	virtual ~GPUHandle();
	virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size) const;
	virtual status_t onTransact(
	uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
	void setOwner(int owner) { mOwner = owner; }
	private:
	void revokeNotification();
	wp<GPUHardware> mGPU;
	sp<IMemoryHeap> mClientHeap;
	int mOwner;
	};

	GPUHandle::~GPUHandle() {
	//LOGD("GPUHandle %p released, revoking GPU", this);
	revokeNotification();
	}

	void GPUHandle::revokeNotification() {
	sp<GPUHardware> hw(mGPU.promote());
	if (hw != 0) {
	hw->revoke(mOwner);
	}
	}
	sp<IMemoryHeap> GPUHandle::getMemory(ssize_t* offset, size_t* size) const
	{
	if (offset) *offset = 0;
	if (size) *size = mClientHeap !=0 ? mClientHeap->virtualSize() : 0;
	return mClientHeap;
	}
	status_t GPUHandle::onTransact(
	uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
	{
	status_t err = BnMemory::onTransact(code, data, reply, flags);
	if (err == UNKNOWN_TRANSACTION && code == 1000) {
	int callingPid = IPCThreadState::self()->getCallingPid();
	//LOGD("pid %d voluntarily revoking gpu", callingPid);
	if (callingPid == mOwner) {
	revokeNotification();
	// we've revoked the GPU, don't do it again later when we
	// are destroyed.
	mGPU.clear();
	} else {
	LOGW("%d revoking someone else's gpu? (owner=%d)",
	callingPid, mOwner);
	}
	err = NO_ERROR;
	}
	return err;
	}

	// ---------------------------------------------------------------------------

	class MemoryHeapRegs : public MemoryHeapPmem
	{
	public:
	MemoryHeapRegs(const wp<GPUHardware>& gpu, const sp<MemoryHeapBase>& heap);
	virtual ~MemoryHeapRegs();
	sp<IMemory> mapMemory(size_t offset, size_t size);
	virtual void revoke();
	private:
	wp<GPUHardware> mGPU;
	};

	MemoryHeapRegs::MemoryHeapRegs(const wp<GPUHardware>& gpu, const sp<MemoryHeapBase>& heap)
	: MemoryHeapPmem(heap), mGPU(gpu)
	{
	#if HAVE_ANDROID_OS
	if (heapID()>0) {
	/* this is where the GPU is powered on and the registers are mapped
	* in the client */
	//LOGD("ioctl(HW3D_GRANT_GPU)");
	int err = ioctl(heapID(), HW3D_GRANT_GPU, base());
	if (err) {
	// it can happen if the master heap has been closed already
	// in which case the GPU already is revoked (app crash for
	// instance).
	//LOGW("HW3D_GRANT_GPU failed (%s), mFD=%d, base=%p",
	// strerror(errno), heapID(), base());
	}
	}
	#endif
	}

	MemoryHeapRegs::~MemoryHeapRegs()
	{
	}

	sp<IMemory> MemoryHeapRegs::mapMemory(size_t offset, size_t size)
	{
	sp<GPUHandle> memory;
	sp<GPUHardware> gpu = mGPU.promote();
	if (heapID()>0 && gpu!=0)
	memory = new GPUHandle(gpu, this);
	return memory;
	}

	void MemoryHeapRegs::revoke()
	{
	MemoryHeapPmem::revoke();
	#if HAVE_ANDROID_OS
	if (heapID() > 0) {
	//LOGD("ioctl(HW3D_REVOKE_GPU)");
	int err = ioctl(heapID(), HW3D_REVOKE_GPU, base());
	LOGE_IF(err, "HW3D_REVOKE_GPU failed (%s), mFD=%d, base=%p",
	strerror(errno), heapID(), base());
	}
	#endif
	}

	// ---------------------------------------------------------------------------

	class GPURegisterHeap : public PMemHeapInterface
	{
	public:
	GPURegisterHeap(const sp<GPUHardware>& gpu)
	: PMemHeapInterface("/dev/hw3d", GPUR_SIZE), mGPU(gpu)
	{
	}
	virtual ~GPURegisterHeap() {
	}
	virtual sp<MemoryHeapPmem> createClientHeap() {
	sp<MemoryHeapBase> parentHeap(this);
	return new MemoryHeapRegs(mGPU, parentHeap);
	}
	private:
	wp<GPUHardware> mGPU;
	};

	/*****************************************************************************/

	GPUHardware::GPUHardware()
	: mOwner(NO_OWNER)
	{
	}

	GPUHardware::~GPUHardware()
	{
	}

	sp<MemoryDealer> GPUHardware::request(int pid)
	{
	sp<MemoryDealer> dealer;

	LOGD("pid %d requesting gpu surface (current owner = %d)", pid, mOwner);

	const int self_pid = getpid();
	if (pid == self_pid) {
	// can't use GPU from surfaceflinger's process
	return dealer;
	}

	Mutex::Autolock _l(mLock);

	if (mOwner != pid) {
	// someone already has the gpu.
	takeBackGPULocked();

	// releaseLocked() should be a no-op most of the time
	releaseLocked();

	requestLocked();
	}

	dealer = mAllocator;
	mOwner = pid;
	if (dealer == 0) {
	mOwner = SURFACE_FAILED;
	}

	LOGD_IF(dealer!=0, "gpu surface granted to pid %d", mOwner);
	return dealer;
	}

	status_t GPUHardware::request(const sp<IGPUCallback>& callback,
	ISurfaceComposer::gpu_info_t* gpu)
	{
	sp<IMemory> gpuHandle;
	IPCThreadState* ipc = IPCThreadState::self();
	const int pid = ipc->getCallingPid();
	const int self_pid = getpid();

	LOGD("pid %d requesting gpu core (owner = %d)", pid, mOwner);

	if (pid == self_pid) {
	// can't use GPU from surfaceflinger's process
	return PERMISSION_DENIED;
	}

	Mutex::Autolock _l(mLock);
	if (mOwner != pid) {
	// someone already has the gpu.
	takeBackGPULocked();

	// releaseLocked() should be a no-op most of the time
	releaseLocked();

	requestLocked();
	}

	if (mHeapR.isValid()) {
	gpu->count = 2;
	gpu->regions[0].region = mHeap0.map(true);
	gpu->regions[0].reserved = mHeap0.reserved;
	gpu->regions[1].region = mHeap1.map(true);
	gpu->regions[1].reserved = mHeap1.reserved;
	gpu->regs = mHeapR.map();
	if (gpu->regs != 0) {
	static_cast< GPUHandle* >(gpu->regs.get())->setOwner(pid);
	}
	mCallback = callback;
	mOwner = pid;
	//LOGD("gpu core granted to pid %d, handle base=%p",
	// mOwner, gpu->regs->pointer());
	} else {
	LOGW("couldn't grant gpu core to pid %d", pid);
	}

	return NO_ERROR;
	}

	void GPUHardware::revoke(int pid)
	{
	Mutex::Autolock _l(mLock);
	if (mOwner > 0) {
	if (pid != mOwner) {
	LOGW("GPU owned by %d, revoke from %d", mOwner, pid);
	return;
	}
	//LOGD("revoke pid=%d, owner=%d", pid, mOwner);
	// mOwner could be <0 if the same process acquired the GPU
	// several times without releasing it first.
	mCondition.signal();
	releaseLocked(true);
	}
	}

	status_t GPUHardware::friendlyRevoke()
	{
	Mutex::Autolock _l(mLock);
	takeBackGPULocked();
	//LOGD("friendlyRevoke owner=%d", mOwner);
	releaseLocked(true);
	return NO_ERROR;
	}

	void GPUHardware::takeBackGPULocked()
	{
	sp<IGPUCallback> callback = mCallback;
	mCallback.clear();
	if (callback != 0) {
	callback->gpuLost(); // one-way
	mCondition.waitRelative(mLock, ms2ns(250));
	}
	}

	void GPUHardware::requestLocked()
	{
	if (mAllocator == 0) {
	GPUPart* part = 0;
	sp<PMemHeap> surfaceHeap;
	if (mHeap1.promote() == false) {
	//LOGD("requestLocked: (1) creating new heap");
	mHeap1.set(new PMemHeap("/dev/pmem_gpu1", 0, GPU_RESERVED_SIZE));
	}
	if (mHeap1.isValid()) {
	//LOGD("requestLocked: (1) heap is valid");
	// NOTE: if GPU1 is available we use it for our surfaces
	// this could be device specific, so we should do something more
	// generic
	surfaceHeap = static_cast< PMemHeap* >( mHeap1.getHeap().get() );
	part = &mHeap1;
	if (mHeap0.promote() == false) {
	//LOGD("requestLocked: (0) creating new heap");
	mHeap0.set(new PMemHeap("/dev/pmem_gpu0"));
	}
	} else {
	//LOGD("requestLocked: (1) heap is not valid");
	// No GPU1, use GPU0 only
	if (mHeap0.promote() == false) {
	//LOGD("requestLocked: (0) creating new heap");
	mHeap0.set(new PMemHeap("/dev/pmem_gpu0", 0, GPU_RESERVED_SIZE));
	}
	if (mHeap0.isValid()) {
	//LOGD("requestLocked: (0) heap is valid");
	surfaceHeap = static_cast< PMemHeap* >( mHeap0.getHeap().get() );
	part = &mHeap0;
	}
	}

	if (mHeap0.isValid() \|\| mHeap1.isValid()) {
	if (mHeapR.promote() == false) {
	//LOGD("requestLocked: (R) creating new register heap");
	mHeapR.set(new GPURegisterHeap(this));
	}
	} else {
	// we got nothing...
	mHeap0.clear();
	mHeap1.clear();
	}

	if (mHeapR.isValid() == false) {
	//LOGD("requestLocked: (R) register heap not valid!!!");
	// damn, couldn't get the gpu registers!
	mHeap0.clear();
	mHeap1.clear();
	surfaceHeap.clear();
	part = NULL;
	}

	if (surfaceHeap != 0 && part && part->getClientHeap()!=0) {
	part->reserved = GPU_RESERVED_SIZE;
	part->surface = true;
	mAllocatorDebug = static_cast<SimpleBestFitAllocator*>(
	surfaceHeap->getAllocator().get());
	mAllocator = new MemoryDealer(
	part->getClientHeap(),
	surfaceHeap->getAllocator());
	}
	}
	}

	void GPUHardware::releaseLocked(bool dispose)
	{
	/*
	* if dispose is set, we will force the destruction of the heap,
	* so it is given back to other systems, such as camera.
	* Otherwise, we'll keep a weak pointer to it, this way we might be able
	* to reuse it later if it's still around.
	*/
	//LOGD("revoking gpu from pid %d", mOwner);
	mOwner = NO_OWNER;
	mAllocator.clear();
	mCallback.clear();

	/* if we're asked for a full revoke, dispose only of the heap
	* we're not using for surface (as we might need it while drawing) */
	mHeap0.release(mHeap0.surface ? false : dispose);
	mHeap1.release(mHeap1.surface ? false : dispose);
	mHeapR.release(false);
	}

	// ----------------------------------------------------------------------------
	// for debugging / testing ...

	sp<SimpleBestFitAllocator> GPUHardware::getAllocator() const {
	Mutex::Autolock _l(mLock);
	sp<SimpleBestFitAllocator> allocator = mAllocatorDebug.promote();
	return allocator;
	}

	void GPUHardware::unconditionalRevoke()
	{
	Mutex::Autolock _l(mLock);
	releaseLocked();
	}

	// ---------------------------------------------------------------------------


	GPUHardware::GPUPart::GPUPart()
	: surface(false), reserved(0)
	{
	}

	GPUHardware::GPUPart::~GPUPart() {
	}

	const sp<PMemHeapInterface>& GPUHardware::GPUPart::getHeap() const {
	return mHeap;
	}

	const sp<MemoryHeapPmem>& GPUHardware::GPUPart::getClientHeap() const {
	return mClientHeap;
	}

	bool GPUHardware::GPUPart::isValid() const {
	return ((mHeap!=0) && (mHeap->base() != MAP_FAILED));
	}

	void GPUHardware::GPUPart::clear()
	{
	mHeap.clear();
	mHeapWeak.clear();
	mClientHeap.clear();
	surface = false;
	}

	void GPUHardware::GPUPart::set(const sp<PMemHeapInterface>& heap)
	{
	mHeapWeak.clear();
	if (heap!=0 && heap->base() == MAP_FAILED) {
	mHeap.clear();
	mClientHeap.clear();
	} else {
	mHeap = heap;
	mClientHeap = mHeap->createClientHeap();
	}
	}

	bool GPUHardware::GPUPart::promote()
	{
	//LOGD("mHeapWeak=%p, mHeap=%p", mHeapWeak.unsafe_get(), mHeap.get());
	if (mHeap == 0) {
	mHeap = mHeapWeak.promote();
	}
	if (mHeap != 0) {
	if (mClientHeap != 0) {
	mClientHeap->revoke();
	}
	mClientHeap = mHeap->createClientHeap();
	} else {
	surface = false;
	}
	return mHeap != 0;
	}

	sp<IMemory> GPUHardware::GPUPart::map(bool clear)
	{
	sp<IMemory> memory;
	if (mClientHeap != NULL) {
	memory = mClientHeap->mapMemory(0, mHeap->virtualSize());
	if (clear && memory!=0) {
	//StopWatch sw("memset");
	memset(memory->pointer(), 0, memory->size());
	}
	}
	return memory;
	}

	void GPUHardware::GPUPart::release(bool dispose)
	{
	if (mClientHeap != 0) {
	mClientHeap->revoke();
	mClientHeap.clear();
	}
	if (dispose) {
	if (mHeapWeak!=0 && mHeap==0) {
	mHeap = mHeapWeak.promote();
	}
	if (mHeap != 0) {
	mHeap->dispose();
	mHeapWeak.clear();
	mHeap.clear();
	} else {
	surface = false;
	}
	} else {
	if (mHeap != 0) {
	mHeapWeak = mHeap;
	mHeap.clear();
	}
	}
	}

	// ---------------------------------------------------------------------------
	}; // namespace android