vid_inf.c

IBM source for pallas/vulcan/vesta

            PDEBUG("END OF STREAM\n");
            ret = vid_osd_end_stream();
            break;

        case MPEG_VID_GET_BUF_SIZE:     //get clip buffer size
            PDEBUG("GET CLIP BUFFER SIZE\n");
            *((unsigned long *)ioctl_param) = vid_osd_get_clip_mem_size();
            break;
        case MPEG_VID_SET_SCALE_POS:
            {
                RECT src, des;
                PDEBUG("SET SCALE POSITION\n");
                copy_from_user(&src, &(((SCALEINFO*)ioctl_param)->src), sizeof(RECT));
                copy_from_user(&des, &(((SCALEINFO*)ioctl_param)->des), sizeof(RECT));

                vid_osi_set_scalepos(&src, &des);
                break;
            }
        case MPEG_VID_SCALE_ON:
            PDEBUG("SCALE ON\n");
            vid_osi_scale_on(ioctl_param);
            break;
        case MPEG_VID_SCALE_OFF:
            PDEBUG("SCALE OFF\n");
            vid_osi_scale_off(ioctl_param);
            break;
        case MPEG_VID_GET_SYNC_INFO:
            {
                STC_T stc, pts;
                vid_osi_get_stc(&stc);
                //actully video pts can not be read, dummy read
                vid_osi_get_pts(&pts);
                copy_to_user(&(((SYNCINFO*)ioctl_param)->stc), &stc, sizeof(STC_T));
                copy_to_user(&(((SYNCINFO*)ioctl_param)->pts), &pts, sizeof(STC_T));
                break;
            }
        case MPEG_VID_SET_SYNC_STC:
            {
                STC_T stc;
                copy_from_user(&stc, &(((SYNCINFO*)ioctl_param)->stc), sizeof(STC_T));
                vid_osi_set_stc(&stc);
                break;
            }
/*        case MPEG_VID_SET_SYNC_TYPE:
            vid_osi_set_sync_type(ioctl_param);
            break;
*/
        case MPEG_VID_SYNC_ON:
            vid_osi_set_sync_type(ioctl_param);
            ret = vid_osi_enable_sync();
            break;
        case MPEG_VID_SYNC_OFF:
            vid_osi_disable_sync();
            break;
        case MPEG_VID_SET_DISPSIZE:
            ret = vid_osi_set_dispsize(ioctl_param);
            break;
        case MPEG_VID_GET_V_INFO:
            {
                VIDEOINFO v_info;
                ret = vid_osi_get_v_info(&v_info);
                if(ret == 0)
                    copy_to_user((VIDEOINFO*)ioctl_param, &v_info, sizeof(VIDEOINFO));
                break;
            }
        case MPEG_VID_SET_DISPFMT:
                if(ioctl_param == VID_DISPFMT_NTSC)
                    vid_osi_set_dispfmt(VID_DISPFMT_NTSC);
                else if(ioctl_param == VID_DISPFMT_PAL)
                    vid_osi_set_dispfmt(VID_DISPFMT_PAL);
                break;
         case MPEG_VID_SET_OUTFMT:
             ret = scrman_osi_set_output(ioctl_param);
             break;
         case MPEG_VID_ENABLE_DISP_14_9:
            ret = vid_osi_enable_disp_14_9(ioctl_param);
            break;
         case MPEG_VID_DISABLE_DISP_14_9:
            ret = vid_osi_disable_disp_14_9(ioctl_param);
            break;
        case MPEG_VID_SET_DISPMODE:
                ret = vid_osi_set_dispmode(ioctl_param);
                break;
        case MPEG_VID_START_STILLP:
                ret = -1;
                if(_src == 1)
                {
                    /*-------------------------------------------------------
                    |clear last clip operation
                    | WARNING: this operation will disrupt last clip
                    +--------------------------------------------------------*/
                    vid_osi_close_clip();
                }
                else if(_src == 0)
                {
                    vid_osi_close_tv();
                }
                if(vid_osd_init_stillp() < 0)
                {
                    ret = -1;
                    break;
                }
                _still_p = 1;
                        _src = 1;
                ret = 0;
                break;
        case MPEG_VID_STOP_STILLP:
                ret = 0;
                if(_still_p == 0)
                    break;
                vid_osi_close_stillp();
                _still_p = 0;
                _src = -1;
                break;
        case MPEG_VID_STILLP_READY:
                ret = vid_osi_stillp_ready();
                break;
        case MPEG_VID_STILLP_WRITE:
            {
                BUFINFO buf;
                ret = -1;
                copy_from_user(&buf, (BUFINFO*)ioctl_param, sizeof(BUFINFO));
                if( vid_osd_write(file, (void*)(buf.ulStartAdrOff), buf.ulLen)
                    == buf.ulLen)
                    ret = 0;
                break;
            }
        case MPEG_VID_STILLP_READ:
            {
                READINFO ri;
                ULONG adr;
                ret = 0;
                copy_from_user(&ri, (READINFO*)ioctl_param, sizeof(READINFO));
                adr = vid_atom_get_stillp_buf(ri.color) + ri.offset;
                copy_to_user(ri.buf, (void*)adr, ri.size);
                break;
            }

//lingh added for PVR demo
                case MPEG_VID_SET_RB_SIZE:
                        {
                                vid_atom_set_rb_size(ioctl_param);
                                break;
                        }
                case MPEG_VID_SINGLE_FRAME:
                        {
                                ret = vid_osi_single_frame(ioctl_param);
                                break;
                        }
                case MPEG_VID_SF_READY:
                        {
                                ret = vid_osi_single_frame_complete();
                                break;
                        }
                case MPEG_VID_RESUME_FROM_SF:
                        {
                                ret = vid_atom_resume_from_sf(ioctl_param);
                                break;
                        }
                case MPEG_VID_RESET_RB:
                        {
                                ret = vid_atom_reset_ratebuf(ioctl_param);
                                break;
                        }

                case MPEG_VID_RESET_CLIPBUF:
                        //make sure video has stopped before this call
                        {
                                ret = vid_osi_reset_clipbuf();
                break;
                        }

        case MPEG_VID_CLIP_CC:
            {
                ret = vid_osi_clip_cc();
                break;
            }

        case MPEG_VID_CLIP_FLUSH:
            {
                ret = vid_osi_clip_flush();
                break;
            }

        case MPEG_VID_CC_COMPLETE:
            {
                ret = vid_osd_cc_complete();
                break;
            }

	case MPEG_VID_PLAY_STATUS:
	    {
	        VIDPLAYSTATUS status;

//              copy_from_user(&status, (void *)ioctl_param, sizeof(status));
                vid_osi_play_status(&status);
                copy_to_user((void *)ioctl_param, &status, sizeof(status));
	        break;
	    }


        case MPEG_VID_SET_SFM:
	    {
	      ret = vid_osi_set_sfm((vidsfm_t)ioctl_param);
	      break;
	    }
	    
        default:
            PDEBUG("NOT SUPPORT\n");
            ret = -1;
    }

    return ret;
}

static unsigned int vid_inf_poll(struct file *filp,
                                 struct poll_table_struct *wait)
{
    PDEBUG("not finished yet\n");
    return 0;
}

static struct file_operations Fops = {
    read:   vid_inf_read,
    write:  vid_inf_write,
    ioctl:  vid_inf_ioctl,
    open:   vid_inf_open,
    release:vid_inf_release,
    poll:   vid_inf_poll,
    mmap:   vid_inf_mmap
};


static struct {
                char *name;
		int minor;
		struct file_operations *fops;
		devfs_handle_t devfs_handle;
              } devnodes[] = { 
			                  {"vid",0,&Fops,0},
					  {"vdec_dev",0,&Fops,0},
				       };

static int no_devnodes = sizeof(devnodes)/sizeof(devnodes[0]);

/* Initialize the module - Register the character device */
int vid_init_module()
{
    int ret_val;
    devfs_handle_t devfs_handle;
    int i;

    scrman_osi_init();
    vid_osd_init();
    vid_osd_close();

    /* Register the character device (atleast try) */
    ret_val = devfs_register_chrdev(MAJOR_NUM_VDEC, DEVICE_NAME_VDEC, &Fops);
    /* Negative values signify an error */
    if (ret_val < 0)
    {
        PDEBUG("VID: %s failed with %d\n",
               "Sorry, registering the character device ", ret_val);
        return ret_val;
    }
    

    for(i=0; i < no_devnodes; i++)
    {
      devfs_handle = devfs_find_handle(NULL, devnodes[i].name,
                                0, 0, DEVFS_SPECIAL_CHR,0);
    
      if(devfs_handle == NULL)
      {
        devfs_handle = devfs_register(NULL, devnodes[i].name, DEVFS_FL_DEFAULT,
                                      MAJOR_NUM_VDEC, devnodes[i].minor,
                                      S_IFCHR | S_IRUSR | S_IWUSR,
                                      devnodes[i].fops, NULL);
        devnodes[i].devfs_handle = devfs_handle;
      }
      else
      {
        devnodes[i].devfs_handle = NULL;
      }
    }
    

    //the following was moved from vid_osi_init    
    //install interrupt handler
     if(os_install_irq(IRQ_VID, 
                      IRQ_LEVEL_TRIG | IRQ_POSITIVE_TRIG,
					  vid_atom_irq_handle,
					  (void*)&_videoDecoder) != 0)
    {
        PDEBUG("install interrupt handler error\n");
        devfs_unregister_chrdev(MAJOR_NUM_VDEC, DEVICE_NAME_VDEC);
        for(i = 0; i < no_devnodes; i++)
        {
          if(devnodes[i].devfs_handle != NULL)
            devfs_unregister(devnodes[i].devfs_handle);
        }
        return -1;
    }

    //DEMUX_REG_AVCB(&vid_callback, 1, 1);
    PDEBUG("VID: Initialize vdec_dev OK!\n");
    return 0;
}

/* Cleanup - unregister the appropriate file from /proc */
void vid_cleanup_module()
{
    int ret;
    int i;

   // the following was moved from vid_osi_close 
   os_uninstall_irq(IRQ_VID);      //remove irq handler


    /* Unregister the device */
    //DEMUX_REG_AVCB(NULL, 1, 0);
    ret = devfs_unregister_chrdev(MAJOR_NUM_VDEC, DEVICE_NAME_VDEC);
    /* If there's an error, report it */
    if (ret < 0)
        printk("Error in module_unregister_chrdev: %d\n", ret);

    for(i = 0; i < no_devnodes; i++)
    {
      if(devnodes[i].devfs_handle != NULL)
        devfs_unregister(devnodes[i].devfs_handle);

    }

    return;
}