vid_osi.c

IBM source for pallas/vulcan/vesta

{
    unsigned reg;
    
    if(_videoDecoder.state == VID_SINGLE_FRAME) 
    {
      // already in single frame mode -- advance one frame
      reg = MF_DCR(VID_CHIP_CTRL);
      MT_DCR(VID_CHIP_CTRL, reg | DECOD_CHIP_CONTROL_SVD); 
    }
    else if(vid_atom_single_frame(mode) != 0)
    {
        PDEBUG("vid_atom_single_frame(%d) failed\n",mode);
    }
    _videoDecoder.state = VID_SINGLE_FRAME;
    return 0;
}

void vid_osi_blank()
{
    PDEBUG("video blank\n");
    vid_atom_blank();
}

void vid_osi_show()
{
    PDEBUG("video show\n");
    vid_atom_show();
}

/*---------------------------------------------------------------------------+
| GET microcode version
+----------------------------------------------------------------------------*/
INT vid_osi_get_microcode_ver(ULONG *pVer)
{
   return vid_atom_get_microcode_ver(pVer);
}


INT vid_osi_init_tv()
{
    if(_videoDecoder.uOpenFlag == 0)
    {
        PDEBUG("video decoder not initialized\n");
        return -1;
    }
    if(_videoDecoder.src != VID_SOURCE_NO)
    {
        PDEBUG("video decoder is in use, src = %d\n", _videoDecoder.src);
        return -1;
    }
    
    if(vid_atom_init_tv(&(_videoDecoder.ratebuf), 0) != 0)
        return -1;
    _videoDecoder.src = VID_SOURCE_DEMUX;
    return 0;
}

void vid_osi_close_tv()
{
    if(_videoDecoder.state != VID_STOPPED)
        vid_osi_stop(1);
    _videoDecoder.src = VID_SOURCE_NO;
}


INT vid_osi_init_clip(UINT uClipBufPhyAdr, UINT uClipBufLen)
{
PDEBUG("vid_osi_init_clip: start\n");
    if(_videoDecoder.uOpenFlag == 0)
    {
        PDEBUG("video decoder not initialized\n");
        return -1;
    }
    if(_videoDecoder.src != VID_SOURCE_NO)
    {
        PDEBUG("video decoder is in use, src = %d\n", _videoDecoder.src);
        return -1;
    }

    //make sure clip buffer is 128bytes aligned and the size
    //is 32 bytes aligned.
    _videoDecoder.clipbuf.uAddr = uClipBufPhyAdr;
    _videoDecoder.clipbuf.uLen  = uClipBufLen;
    //_videoDecoder.uClipBufLogAdr = uClipBufLogAdr;

    if(vid_atom_init_clip(&(_videoDecoder.clipbuf)) != 0)
        return -1;

    //create clip device
    if(uClipBufLen%(VID_CLIP_QUEUE_SIZE*256) != 0)
    {
        PDEBUG("clip buffer not 4k aligned \n");
        return -1;
    }

    if((_videoDecoder.clipdev = clipdev_create(uClipBufLen / VID_CLIP_QUEUE_SIZE,
                                       VID_CLIP_QUEUE_SIZE,
                                       vid_osi_clip_write,
                                       vid_atom_buf_ready)) == NULL)
    {
	PDEBUG("create clip device error\n");
        return -1;
    }

    _videoDecoder.src = VID_SOURCE_MEMORY;

    //clear frame buffer
    vid_atom_clear_framebuf();

    PDEBUG("clip mode init OK\n");
    //vid_atom_reg_dump();
    return 0;
}

void vid_osi_close_clip()
{
    if(_videoDecoder.state != VID_STOPPED)
        vid_osi_stop(1);
    
    vid_atom_close_clip();
    if(_videoDecoder.clipdev)
    {
        clipdev_delete(_videoDecoder.clipdev);
        _videoDecoder.clipdev = NULL;
    }

    _videoDecoder.src = VID_SOURCE_NO;
}

INT vid_osi_reset_clipbuf()
{
    if(_videoDecoder.clipdev)
    {
        clipdev_delete(_videoDecoder.clipdev);
        _videoDecoder.clipdev = NULL;
    }
    if((_videoDecoder.clipdev = clipdev_create(_videoDecoder.clipbuf.uLen / VID_CLIP_QUEUE_SIZE,
                                       VID_CLIP_QUEUE_SIZE,
                                       vid_osi_clip_write,
                                       vid_atom_buf_ready)) == NULL)
    {
		PDEBUG("create clip device error\n");
        return -1;
    }
	return 0;
}


void* vid_osi_get_stillp_buf(int color)
{
    //int flag;
    //ULONG adr;

    if(_videoDecoder.state != VID_STILLP)
        return NULL;
    
    return (void*)vid_atom_get_stillp_buf(color);
    //return os_get_logical_address(_videoDecoder.spBuf);
    //flag = ((*((unsigned short*)(_videoDecoder.ulUserBufLogAdr + USER_DATA_H_SIZE))) & 0xFFF0) >> 4;
}

INT vid_osi_init_stillp(UINT uClipBufPhyAdr, UINT uClipBufLen)
{

PDEBUG("vid_osi_init_stillp: start\n");

    if(_videoDecoder.uOpenFlag == 0)
    {
        PDEBUG("video decoder not initialized\n");
        return -1;
    }
    if(_videoDecoder.src != VID_SOURCE_NO)
    {
        PDEBUG("video decoder is in use, src = %d\n", _videoDecoder.src);
        return -1;
    }

    //make sure clip buffer is 128bytes aligned and the size
    //is 32 bytes aligned.
    _videoDecoder.clipbuf.uAddr = uClipBufPhyAdr;
    _videoDecoder.clipbuf.uLen  = uClipBufLen;
    //_videoDecoder.uClipBufLogAdr = uClipBufLogAdr;

    //if(vid_atom_init_clip(&(_videoDecoder.clipbuf)) != 0)
    //    return -1;

    if(vid_atom_enter_stillp(VID_RB_MEM_BASE) < 0)
    {
        //if(_videoDecoder.spBuf)
        //    os_free_physical(_videoDecoder.spBuf);
        return -1;
    }

    //create clip device
    if(uClipBufLen%(VID_CLIP_QUEUE_SIZE*256) != 0)
    {
        PDEBUG("clip buffer not 4k aligned \n");
        return -1;
    }

    if((_videoDecoder.clipdev = clipdev_create(uClipBufLen / VID_CLIP_QUEUE_SIZE,
                                       VID_CLIP_QUEUE_SIZE,
                                       vid_osi_clip_write,
                                       vid_atom_buf_ready)) == NULL)
    {
	    PDEBUG("create clip device error\n");
        return -1;
    }

    _videoDecoder.src = VID_SOURCE_MEMORY;
    PDEBUG("stillp mode init OK\n");
    //vid_atom_reg_dump();

    _videoDecoder.state = VID_STILLP;
    _videoDecoder.seq_end = 1;
    return 0;
}

INT vid_osi_close_stillp()
{   
    vid_atom_exit_stillp();
    
    if(_videoDecoder.clipdev)
    {
        clipdev_delete(_videoDecoder.clipdev);
        _videoDecoder.clipdev = NULL;
    }

    _videoDecoder.src = VID_SOURCE_NO;
//    _videoDecoder.state = VID_PLAYING;
    return 0;
}


INT vid_osi_stillp_ready()
{
    UINT32 flags;

    flags = os_enter_critical_section();
    if(_videoDecoder.seq_end == 1)
    {
        _videoDecoder.seq_end = 0;
        os_leave_critical_section(flags);
        return 0;
    }
    os_leave_critical_section(flags);
    return -1;
}
INT vid_osi_clip_cc()
{
   unsigned reg;

   clipdev_stop(_videoDecoder.clipdev);

   MT_DCR(VID_VCLIP_LEN,0);                           /* clear block valid bit */

   MT_DCR(VID_CMD_STAT, 0);                         /* reset video rate buffer */
   MT_DCR(VID_PROC_IADDR, 0x00008200);
   vid_atom_reset_ratebuf(0x8000);

    reg = MF_DCR(VID_CHIP_CTRL);
    MT_DCR(VID_CHIP_CTRL, reg | DECOD_CHIP_CONTROL_SVD);

   _videoDecoder.state = VID_PLAYING;
   return 0;
}

INT vid_osi_clip_flush()
{
   clipdev_stop(_videoDecoder.clipdev);

   MT_DCR(VID_VCLIP_LEN,0);                           /* clear block valid bit */

   MT_DCR(VID_CMD_STAT, 0);                         /* reset video rate buffer */
   MT_DCR(VID_PROC_IADDR, 0x00008200);
   vid_atom_reset_ratebuf(0x0000);

   return 0;
}

void vid_osi_task(QUEUE_T *pQueue)
{
    TASK_MSG msg;

    PDEBUG("vid task\n");
    while( os_get_queue_status(pQueue) > 0)
    {
        //get first message
        if( os_dequeue(pQueue, &msg) != 0 )
        {
            PDEBUG("no message\n");
            return;
        }
        if( msg.uMsgType == VID_MSG_BLOCK_READ)
        {
            PDEBUG("block read msg\n");
            clipdev_clipinfo_done(_videoDecoder.clipdev);
            //write next clip
            clipdev_hw_write(_videoDecoder.clipdev);
            continue;
        }
        if( msg.uMsgType == VID_MSG_SEQUENCE_END)
        {
            UINT32 flags;
            flags = os_enter_critical_section();
            _videoDecoder.seq_end = 1;
            os_leave_critical_section(flags);
            continue;
        }
    }
}

INT  vid_osi_fast_forward(UINT uSpeed)
{
    /*if(_videoDecoder.src != VID_SOURCE_MEMORY)
    {
        PDEBUG("init memory mode first\n");
        return -1;
    }*/
    if(vid_atom_fast_forward(uSpeed) != 0)
        return -1;
    _videoDecoder.state = VID_FASTFORWORD;
    return 0;
}

INT  vid_osi_slow_motion(UINT uSpeed)
{
    /*if(_videoDecoder.src != VID_SOURCE_MEMORY)
    {
        PDEBUG("init memory mode first\n");
        return -1;
    }*/
    if(vid_atom_slow_motion(uSpeed) != 0)
        return -1;
    _videoDecoder.state  = VID_SLOWMOTION;
    return 0;
}

void  vid_osi_set_sync_type(vidSync_t sync)
{
    _videoDecoder.sync = sync;
}

INT  vid_osi_enable_sync()
{
    if(_videoDecoder.sync == VID_SYNC_NO)
    {
        PDEBUG("not set sync type\n");
        return -1;
    }
    if(_videoDecoder.sync == VID_SYNC_VID)
        vid_atom_enable_sync(1);
    else
        vid_atom_enable_sync(0);
    return 0;
}

void vid_osi_disable_sync()
{
    vid_atom_disable_sync();
}


CLIPDEV_T vid_osi_get_clipdev()
{
    if(_videoDecoder.src != VID_SOURCE_MEMORY)
    {
        PDEBUG("init memory mode first\n");
        return NULL;
    }
    return _videoDecoder.clipdev;
}


INT vid_osi_clip_write(CLIPINFO *info)
{
    vid_atom_write_clip(info);
    return 0;
}

void vid_osi_set_pts(STC_T *pData)
{
    vid_atom_set_pts(pData);
}

void vid_osi_get_pts(STC_T *pData)
{
    //vid_atom_get_pts(pData);
    pData->bit0 = 0;
    pData->bit32_1 = 0;
    return;
}

void vid_osi_set_stc(STC_T *pData)
{
    vid_atom_set_stc(pData);
}

void vid_osi_get_stc(STC_T *pData)
{
    vid_atom_get_stc(pData);
}

int vid_osi_single_frame_complete()
{

    if(MF_DCR(VID_CHIP_CTRL) & DECOD_CHIP_CONTROL_SVD)
      return(-1);
    
    return 0;
}

INT vid_osi_enable_disp_14_9(int top_border)
{
    VIDEOCMD vc;
   
    //set the current letterbox top border value
    saved_LB_top_border = MF_DCR(VID_LBOX);
   
    if(top_border != -1)
       MT_DCR(VID_LBOX, top_border); //set the letterbox top border value

    //note: chip must be in letterbox mode
    if(vid_osi_set_dispmode(VID_DISPMODE_LETTERBOX)!=0) {
       printk("Failed to set LETTERBOX mode\n");
       return -1;
    }
    
    vc.uCmd = DECOD_COM_NO_PAN_SCAN;
    vc.uNum = 1;
    vc.uPara[0] = 0x1000; 
    vc.uChained = 0;
    vc.uRetry = DECOD_TIMEOUT;
    if (vid_atom_exec_cmd(&vc) != 0){
      PDEBUG("execute config command failed\n");
      return -1;
    }
  
    return 0;
}

INT vid_osi_disable_disp_14_9()
{
   VIDEOCMD vc;
    
    vc.uCmd = DECOD_COM_NO_PAN_SCAN;
    vc.uNum = 1;
    vc.uPara[0] = 0x0000; 
    vc.uChained = 0;
    vc.uRetry = DECOD_TIMEOUT;
    
    if (vid_atom_exec_cmd(&vc) != 0){
      PDEBUG("execute config command failed\n");
      return -1;
    }
  
    if(vid_osi_set_dispmode(VID_DISPMODE_NORM)!=0) {
       printk("Failed to disable LETTERBOX mode\n");
       return -1;
    }
  
    // restore the top border value back to what it originally was  
    MT_DCR(VID_LBOX, saved_LB_top_border); 
        
    return 0;
}