s3c2440disp.cpp

三星2440原版bsp

            }
            else if(index < 6400)
            {
                ptr[index + 16] = 0x07e0;
            }
            else if(index < 9600)
            {
                ptr[index + 16] = 0x001f;
            }
            else
            {
                ptr[index + 16] = 0xffff;
            }
        }

        // Set Board Control Register (BCR) for Sharp LCD mode
        //set_BCRVal (BCR_LCD_LQ039Q2DS01_16BPP | BCR_LCD_POWER_ON | BCR_BACKLIGHT_ON, NOMASK, INPOWERHANDLER);

        //
        // The SA1111DB card used by the SA11X0BD platform provides a bit to 
        // allow us to choose between MQ200 and SA_LCD.  By default we assume 
        // the display will be a MQ200 (so we can have a generic MQ200 driver) 
        // and only override it if we want to use the LCD driver.  It's wrapped 
        // in a conditional so other SA-based systems can use this library.
        //
	// if (m_bClearAlternateVideoBCR != 0)
  	// {
    	//        set_BCRVal (0, 0x2, INPOWERHANDLER);
      //  }

        // Program GPIO register to enable GPIO lines 2 - 9 for use by the LCD controller
        // disable LCD controller
        // clear LCD Status Register
        // enable LCD controller


        // Restore the screen
        if (NULL != pVideoMemory)
        {
            // Swap the buffers.
            BYTE * pTempBuffer = (BYTE*)m_pPrimarySurface->Buffer();

	     m_pPrimarySurface->Init(m_nScreenWidth, m_nScreenHeight, pVideoMemory, m_cbScanLineLength, m_pMode->format);

            pVideoMemory = pTempBuffer;

            // Actually copy the bits.
            memcpy(m_pPrimarySurface->Buffer(), pVideoMemory, m_FrameBufferSize);

            delete [] pVideoMemory;
            pVideoMemory = NULL;
        }
        else
        {
            memset ((void*)m_pPrimarySurface->Buffer(), 0x0, m_FrameBufferSize);
        }

        m_CursorDisabled = FALSE;
        //CursorOn();
        m_CursorVisible = TRUE;
    }
}

//APR added func override
SCODE S3C2440DISP::GetModeInfoEx(GPEModeEx *pModeEx, int modeNo)
{
	RETAILMSG(DBGLCD, (TEXT("In S3C2440DISP::GetModeInfoEx\r\n")));
	if (modeNo != 0)
    	{
        	return    E_INVALIDARG;
    	}

    	*pModeEx = *m_pModeEx;

    	return S_OK;
}

ULONG *APIENTRY DrvGetMasks(DHPDEV dhpdev)
{
	RETAILMSG(DBGLCD, (TEXT("DrvGetMasks\r\n")));
	if (gGPE == NULL)
        	return(BitMasks[0]);

    	int nBPP = ((S3C2440DISP *)gGPE)->GetBpp()/8 - 1;
    	switch (((S3C2440DISP *)gGPE)->GetBpp())
    	{
//        case 8:
        case 16:
        case 24:
        case 32:
	  {
           return(BitMasks[nBPP]);            	
        }
				
    	}

    	return(BitMasks[0]);
	
	//return gBitMasks;
}

//
// GetBpp
//
// Return the Bpp of the current monitor
//
int S3C2440DISP::GetBpp(void)
{
    return m_pMode->Bpp;
}

//------------------------------------------------------------------------------
//
//   GetGameXInfo
//
//   fill out GAPI information for DrvEscape call
//
int S3C2440DISP::GetGameXInfo(
    ULONG iEsc, ULONG cjIn, VOID *pvIn, ULONG cjOut, VOID *pvOut
) {
    int rc = 0;  

    RETAILMSG(1, (L"+GetGameXInfo \r\n"));

    // GAPI only support P8, RGB444, RGB555, RGB565, and RGB888
    if (
        pvOut != NULL && cjOut >= sizeof(GXDeviceInfo) && (
            m_pMode->Bpp == 8 || m_pMode->Bpp == 12 ||
            m_pMode->Bpp == 16 || m_pMode->Bpp == 24 ||
            m_pMode->Bpp == 32
        )) 
    {
       if(((GXDeviceInfo*)pvOut)->idVersion == kidVersion100)
       {  
        GXDeviceInfo *pInfo = (GXDeviceInfo*)pvOut;
        pInfo->idVersion = kidVersion100;
        
          if( m_DPI == HIGH_DPI_VALUE || ((m_DPI == HIGH_DPI_VALUE_TPC)&&(SMARTFON_SCREEN != QVGA_SUPPORT)) )
            {
               pInfo->pvFrameBuffer = (void *)m_pvDRAMBuffer;
               RETAILMSG(1,(TEXT("DPI Value = %d \r\n"),m_DPI));
                 if( m_DPI == HIGH_DPI_VALUE )
                    {
                      pInfo->cbStride      = DISP_CY_STRIDE;
                      pInfo->cxWidth       = DISP_CX_SCREEN;
                      pInfo->cyHeight      = DISP_CY_SCREEN;
                    }
                 else
                    {
                      pInfo->cbStride      = DISP_CY_STRIDE_TPC;
                      pInfo->cxWidth       = DISP_CX_SCREEN_TPC;
                      pInfo->cyHeight      = DISP_CY_SCREEN_TPC;
                    }
                    pInfo->cBPP = 16;
                    pInfo->ffFormat = kfDirect | kfDirect565;
                    RETAILMSG(TRUE, (TEXT("m_pvDRAMBuffer is %x \r\n"), m_pvDRAMBuffer ));
            }
          else
            {  
              pInfo->pvFrameBuffer = (UCHAR*)m_pPrimarySurface->Buffer();
              pInfo->cbStride = m_pPrimarySurface->Stride();
              pInfo->cxWidth  = m_pPrimarySurface->Width();
              pInfo->cyHeight = m_pPrimarySurface->Height();
             
              switch (m_pMode->Bpp) {
              case 8:
                 pInfo->cBPP = 8;
                 pInfo->ffFormat |= kfPalette;
                 break;
              case 12:
                 pInfo->cBPP = 12;
                 pInfo->ffFormat |= kfDirect | kfDirect444;
                 break;
              case 16:
                 pInfo->cBPP = 16;
                 pInfo->ffFormat |= kfDirect | kfDirect565;
                 break;
              case 24:
                 pInfo->cBPP = 24;
                 pInfo->ffFormat |= kfDirect | kfDirect888;
              case 32:
                 pInfo->cBPP = 32;
                 pInfo->ffFormat |= kfDirect | kfDirect888;
              default:
                 goto cleanUp;
               }
            }
            RETAILMSG(1,(TEXT("Stride=%d, Width=%d, Height=%d, FrmaeBuffer=%x \r\n"),pInfo->cbStride,pInfo->cxWidth,pInfo->cyHeight,pInfo->pvFrameBuffer));
#ifdef ROTATE  
           if (m_iRotate == DMDO_90 || m_iRotate == DMDO_270 )
                    pInfo->ffFormat |= kfLandscape;  // Rotated
#endif //ROTATE & ROTATE

        // todo: get keys from registry
        pInfo->vkButtonUpPortrait = VK_UP;
        pInfo->vkButtonUpLandscape = VK_LEFT;
        pInfo->ptButtonUp.x = 88;
        pInfo->ptButtonUp.y = 250;
        pInfo->vkButtonDownPortrait = VK_DOWN;
        pInfo->vkButtonDownLandscape = VK_RIGHT;
        pInfo->ptButtonDown.x = 88;
        pInfo->ptButtonDown.y = 270;
        pInfo->vkButtonLeftPortrait = VK_LEFT;
        pInfo->vkButtonLeftLandscape = VK_DOWN;
        pInfo->ptButtonLeft.x = 78;
        pInfo->ptButtonLeft.y = 260;
        pInfo->vkButtonRightPortrait = VK_RIGHT;
        pInfo->vkButtonRightLandscape = VK_UP;
        pInfo->ptButtonRight.x = 98;
        pInfo->ptButtonRight.y = 260;

#if 1       // default to Smartphone settings for now
        pInfo->vkButtonAPortrait = VK_F1;   // Softkey 1
        pInfo->vkButtonALandscape = VK_F1;
        pInfo->ptButtonA.x = 10;
        pInfo->ptButtonA.y = 240;
        pInfo->vkButtonBPortrait = VK_F2;   // Softkey 2
        pInfo->vkButtonBLandscape = VK_F2;
        pInfo->ptButtonB.x = 166;
        pInfo->ptButtonB.y = 240;
        pInfo->vkButtonCPortrait = VK_F8;   // Asterisk on keypad
        pInfo->vkButtonCLandscape = VK_F8;
        pInfo->ptButtonC.x = 10;
        pInfo->ptButtonC.y = 320;
#else
        //  Added For GAPI to map Literal A, B, C
        pInfo->vkButtonAPortrait = VK_APP_LAUNCH1;
        pInfo->vkButtonALandscape = VK_APP_LAUNCH1;
        pInfo->ptButtonA.x = 10;
        pInfo->ptButtonA.y = 240;
        pInfo->vkButtonBPortrait = VK_APP_LAUNCH4;
        pInfo->vkButtonBLandscape = VK_APP_LAUNCH4;
        pInfo->ptButtonB.x = 166;
        pInfo->ptButtonB.y = 240;
        pInfo->vkButtonCPortrait = VK_APP_LAUNCH2;   // Asterisk on keypad
        pInfo->vkButtonCLandscape = VK_APP_LAUNCH2;
        pInfo->ptButtonC.x = 10;
        pInfo->ptButtonC.y = 320;
#endif
        pInfo->vkButtonStartPortrait  = '\r';
        pInfo->vkButtonStartLandscape = '\r';
        pInfo->ptButtonStart.x = 88;
        pInfo->ptButtonStart.y = 260;
        pInfo->pvReserved1 = (void *) 0;
        pInfo->pvReserved2 = (void *) 0;
        RETAILMSG(1, (L"-GetGameXInfo \r\n"));
        rc = 1;
    	}
    }
    else {
        SetLastError (ERROR_INVALID_PARAMETER);
        rc = -1;
    }

cleanUp:
    RETAILMSG(DBGLCD, (L"GetGameXInfo(rc = %d\r\n", rc));
    return rc;
}

int S3C2440DISP::GetRotateModeFromReg()
{
    HKEY hKey;

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\ROTATION"), 0, 0, &hKey))
    {
        DWORD dwSize, dwAngle, dwType = REG_DWORD;
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                             TEXT("ANGLE"),
                                             NULL,
                                             &dwType,
                                             (LPBYTE)&dwAngle,
                                             &dwSize))
        {
            switch (dwAngle)
            {
            case 0:
                return DMDO_0;

            case 90:
                return DMDO_90;

            case 180:
                return DMDO_180;

            case 270:
                return DMDO_270;

            default:
                return DMDO_0;
            }
        }

        RegCloseKey(hKey);
    }

    return DMDO_0;
}

void S3C2440DISP::SetRotateParams()
{
    switch(m_iRotate)
    {
    case DMDO_90:
    case DMDO_270:
        m_pMode->height = m_nScreenWidthSave;
        m_pMode->width = m_nScreenHeightSave;
        break;

    case DMDO_0:
    case DMDO_180:
    default:
        m_pMode->width = m_nScreenWidthSave;
        m_pMode->height = m_nScreenHeightSave;
        break;
    }
    return;
}

LONG S3C2440DISP::DynRotate(int angle)
{
    int curRot, oldAngle;
    int ang2idxArr[5]={0,1,2,2,3};
    int angArr[4]={0,1,2,4};

    oldAngle = m_iRotate;
    m_iRotate = angle;

    curRot = ang2idxArr[angle] - ang2idxArr[oldAngle];
    if(curRot < 0)
        curRot += 4;

    //RotateCursorShape(angArr[curRot]);

    SetRotateParams();

	m_nScreenWidth = m_pMode->width;
	m_nScreenHeight = m_pMode->height;
	m_pPrimarySurface->SetRotation(m_nScreenWidth, m_nScreenHeight, angle);

	return DISP_CHANGE_SUCCESSFUL;
}

SCODE S3C2440DISP::RotateCursorShape(int angle)
{
#if 0 	//{
    if (angle == 0)
        return S_OK;

    BYTE *pByte, *pCursor;
    ULONG ulBase, ulIndex;
    BYTE srcAnd[128],srcXor[128], dstAnd[128], dstXor[128]; /* 128 = 4 x 32 */
    BYTE  jMask,jAnd,jXor,bitMask;
    int x, y, cx = 32, cy = 32, tx;

    pCursor = pByte = m_pLAW + m_nCursorMemory + 1024;

    memset(srcAnd, 0x00, sizeof(srcAnd));
    memset(srcXor, 0x00, sizeof(srcXor));
    memset(dstAnd, 0x00, sizeof(dstAnd));
    memset(dstXor, 0x00, sizeof(dstXor));

    //Save the original pointer shape into local memory shapeRow[]
    for (y=0; y<cy; y++)
    {
        srcAnd[y*4+0] = pByte[0x0];
        srcXor[y*4+0] = pByte[0x1];
        srcAnd[y*4+1] = pByte[0x2];
        srcXor[y*4+1] = pByte[0x3];
        srcAnd[y*4+2] = pByte[0x8];
        srcXor[y*4+2] = pByte[0x9];
        srcAnd[y*4+3] = pByte[0xA];
        srcXor[y*4+3] = pByte[0xB];

        pByte+=16;
    }

//    pShape = shapeSrcRow;
    switch (angle)
    {
    case DMDO_90:
        for (y = 0; y < cy; y++)
        {        
            jMask = 0x80 >> (y&7);
            for (x = 0; x < cx; x++)
            {
                ulBase  = (31 - x) * 4;
                ulIndex = (ulBase + y / 8);

                bitMask = 0x80 >> (x&7);
                jAnd = srcAnd[y*4 + (x/8)];
                jXor = srcXor[y*4 + (x/8)];

                if (jAnd & bitMask)
                {
                    dstAnd[ulIndex] |= jMask;
                }
                if (jXor & bitMask)
                {
                    dstXor[ulIndex] |= jMask;
                }
            }
        }

        tx = m_nXHot;
        m_nXHot = m_nYHot;
        m_nYHot = 31 - tx;
        break;

    case DMDO_180:
        for (y = 0; y < cy; y++)
        {
            ulBase = (31 - y) * 4;
            for (x = 0; x < cx; x++)
            {
                jAnd  = srcAnd[y*4 + x/8];
                jXor  = srcXor[y*4 + x/8];
                bitMask  = 0x80 >> (x & 7);
                jMask = 0x01 << (x & 7);

                ulIndex = (ulBase + (32 - x - 1) / 8);
                if (jAnd & bitMask)
                {
                    dstAnd[ulIndex] |= jMask;
                }
                if (jXor & bitMask)
                {
                    dstXor[ulIndex] |= jMask;
                }
            }
        }

        m_nXHot = 31 - m_nXHot;
        m_nYHot = 31 - m_nYHot;
        break;

    case DMDO_270:
         for (y = 0; y < cy; y++)
        {
            jMask  = 0x01 << (y & 7);

            // Write available bits into shapeRow
            for (x = 0; x < cx; x++)
            {
                jAnd  = srcAnd[y*4 + x/8];
                jXor  = srcXor[y*4 + x/8];
                bitMask = 0x80 >> (x & 7);            // Starting here achieves byte swapping

                ulBase = x * 4;
                ulIndex = (ulBase + (31 - y) / 8);

                if (jAnd & bitMask)
                    dstAnd[ulIndex] |= jMask;
                if (jXor & bitMask)
                    dstXor[ulIndex] |= jMask;
            }
        }
        tx = m_nXHot;
        m_nXHot = 31 - m_nYHot;
        m_nYHot = tx;
        break;
    }

    for (y=0; y<cy; y++)
    {
        pCursor[0x0] = dstAnd[y*4+0];
        pCursor[0x1] = dstXor[y*4+0];
        pCursor[0x2] = dstAnd[y*4+1];
        pCursor[0x3] = dstXor[y*4+1];
        pCursor[0x8] = dstAnd[y*4+2];
        pCursor[0x9] = dstXor[y*4+2];
        pCursor[0xa] = dstAnd[y*4+3];
        pCursor[0xb] = dstXor[y*4+3];
        pCursor += 16;
    }
#endif	//}
    return S_OK;
}