xp_osd_drv.c

IBM source for pallas/vulcan/vesta

     DemuxAcq.notify_data_fn = DemuxPESCallback;

   if (DemuxChannelAcquire(pGlobal,pDmxfilter,&DemuxAcq)) {
      printk("DemuxFilterTSSet(): Error acquiring channel for Transport Stream\n");
      return(-ENOMEM);
   }

   if(pDmxfilter->flags & FILTER_FLAG_UNBUFFERED)
   {
     xp_osi_interrupt_channel_notify(pGlobal,
                                      XP_INTERRUPT_NOTIFY_ADD,
                                      pDmxfilter->chid,
				      XP_INTERRUPT_QSTAT_RPI | XP_INTERRUPT_QSTAT_BTI,
				      (XP_INTERRUPT_CHANNEL_FN)DemuxCallback_nb);
   }

   return(0);
}

/*----------------------------------------------------------------------------+
|  DemuxSetBufferSize
|
|  DESCRIPTION: Set size of internel circular buffer.
+----------------------------------------------------------------------------*/
static int DemuxSetBufferSize(
   GLOBAL_RESOURCES *pGlobal,
   DEMUX_FILTER     *pDmxfilter,
   ULONG            size)

{
   PDEBUG("DemuxSetBufferSize(): Entering\n");

   if (pDmxfilter->states >= FILTER_STAT_START)
   {
      DemuxFilterStop(pGlobal,pDmxfilter);
   }

   if (pDmxfilter->buffer.plData)
   {
      vfree(pDmxfilter->buffer.plData);
   }

   pDmxfilter->buffer.plData  = 0;
   pDmxfilter->buffer.ulSize  = size;
   pDmxfilter->buffer.ulRead  = 0;
   pDmxfilter->buffer.ulWrite = -1;

   if (pDmxfilter->states == FILTER_STAT_READY)
   {
      if((pDmxfilter->flags & FILTER_FLAG_UNBUFFERED) == 0)
      {
        pDmxfilter->buffer.plData = vmalloc(pDmxfilter->buffer.ulSize);
        if (!pDmxfilter->buffer.plData)
        {
           return(-ENOMEM);
        }
      }	
   }

   return(0);
}

/*----------------------------------------------------------------------------+
|  DemuxSetACPM
+----------------------------------------------------------------------------*/
static int DemuxSetACPM(
   GLOBAL_RESOURCES *pGlobal,
   ULONG            arg)

{
   XP_CONFIG_VALUES Config;


   PDEBUG("DemuxSetACPM():Entering - uDeviceIndex=%d  arg=%lu\n",pGlobal->uDeviceIndex, arg);

   switch(pGlobal->uDeviceIndex)
   {
      case 0:
         os_get_mutex(hMutex);
         xp_osi_get_config_values(pGlobal,&Config);
         if (arg != 0)
         {
            Config.acpm = 1;
         } else {
            Config.acpm = 0;
         }

         xp_osi_set_config_values(pGlobal,&Config);
         os_release_mutex(hMutex);
         break;

       default:
         return(-1);
         break;
   }

   return(0);
}

/*----------------------------------------------------------------------------+
|  DemuxSetVCPM
+----------------------------------------------------------------------------*/
static int DemuxSetVCPM(
   GLOBAL_RESOURCES *pGlobal,
   ULONG            arg)

{
   XP_CONFIG_VALUES Config;


   PDEBUG("DemuxSetVCPM(): Entering\n");

   switch(pGlobal->uDeviceIndex)
   {
      case 0:
         os_get_mutex(hMutex);
         xp_osi_get_config_values(pGlobal,&Config);
         if (arg != 0)
         {
            Config.vcpm = 1;
         } else {
            Config.vcpm = 0;
         }

         xp_osi_set_config_values(pGlobal,&Config);
         os_release_mutex(hMutex);
         break;

      default:
         return(-1);
         break;
   }

   return(0);
}

/*----------------------------------------------------------------------------+
|  demux_filter_get_queue
+-----------------------------------------------------------------------------+
|  DESCRIPTION: This function returns the current read pointer and write 
|  pointer offsets for the demux queue.  
+----------------------------------------------------------------------------*/
static int demux_filter_get_queue(
   struct file      *file,
   GLOBAL_RESOURCES *pGlobal,
   DEMUX_FILTER     *pDmxfilter,
   queue_para       *qpara)

{
  UINT32             flag;
  ULONG pread;
  ULONG pwrite;
  QUEUE_PTR        pQue;     /* channel information          */

  PDEBUG1("demux_filter_get_queue(): Entering\n");

  qpara->readptr = 0;
  qpara->writeptr = 0;
    
  while(1)
  {
    if (!pDmxfilter || pDmxfilter->states < FILTER_STAT_START) 
    {
      printk("demux_filter_get_queue(): filter not started");
      return(-EINVAL);
    }
    
    if(pDmxfilter->chid == ILLEGAL_CHANNEL)
    {
      printk("demux_filter_get_queue(): ILLEGAL CHANNEL");
      return(-EINVAL);
    }

    if((pDmxfilter->flags & FILTER_FLAG_UNBUFFERED) == 0)
    {
      printk("demux_filter_get_queue(): filter not in unbuffered mode");
      return(-EINVAL);
    }

    flag = os_enter_critical_section();
    
    pread = pDmxfilter->buffer.ulRead;      
    pwrite = pDmxfilter->buffer.ulWrite;

    if(pwrite == -1)                          /* initial value is set to -1 */
      pwrite = 0;
      
//      printk("ppBQueue=%08X ppEQueue=%08X pread=%08X pwrite=%08X\n",
//              ppBQueue,ppEQueue,pread,pwrite);
	    
    if(pread != pwrite)        
    {
      os_leave_critical_section(flag);
      break;
    }
    
    // If the filter is opened in non-block mode, return
    if (file->f_flags & O_NONBLOCK)
    {
      os_leave_critical_section(flag);
//      printk("demux_filter_get_queue(): -EWOULDBLOCK");
      return(-EWOULDBLOCK);
    }

    // sleep upon filter's queue, waiting data available
    if (pDmxfilter->para.timeout > 0)
    {
      if(0 == interruptible_sleep_on_timeout(&pDmxfilter->buffer.queue,
                                     (UINT)(pDmxfilter->para.timeout/10)))
      {				      
        os_leave_critical_section(flag);
//        printk("demux_filter_get_queue(): -ETIMEDOUT");
        return(-ETIMEDOUT);					  
      }
    } else 
       interruptible_sleep_on(&pDmxfilter->buffer.queue);
    
    os_leave_critical_section(flag);
    if (signal_pending(current))
    {
      printk("demux_filter_get_queue(): -EINTR");
      return(-EINTR);
    }
      
  }

  /*--------------------------------------------------------------------+
  |  Get the queue range, and the address range of the data
  +--------------------------------------------------------------------*/

//  printk("pread = %8.8x ",(int)pread);
//  printk("pwrite = %8.8x ",(int)pwrite);
//  printk("ppBQueue = %8.8x ",(int)ppBQueue);
//  printk("ppEQueue = %8.8x\n",(int)ppEQueue);

  /*--------------------------------------------------------------------+
  |  make sure the address range is within the bounds of the queue
  +--------------------------------------------------------------------*/
  pQue = &pGlobal->QueueInfo.XpQueueChData[pDmxfilter->chid];
  if(pQue->hMem == 0)
  {
    printk("demux_filter_get_queue(): queue not allocated");
    return(-EINVAL);
  }

  if((pread >= pQue->ulQueueSize) || (pwrite >= pQue->ulQueueSize))
  {
    PDEBUG("XP_ERROR_QUEUE_ADDRESS1\n");
    printk("demux_filter_get_queue(): invalid pread(%d) or pwrite(%d)\n",(int)pread,(int)pwrite);
    pQue->Errors.uwQueueAddress++;
    return(-EINVAL);
  }

  /*--------------------------------------------------------------------+
  |  Check if queue is not active, then we'll skip the new record
  |  which must have arrived in the hardware when we changed the state
  |  to DISABLED.
  +--------------------------------------------------------------------*/
  if(pQue->State != XP_QUEUE_STATUS_ENABLED)
  {
    printk("pChannel->Errors.uwQueueDisabled\n");
    pQue->Errors.uwQueueDisabled++;
    return(-EINVAL);
  }

  qpara->readptr = pread;
  qpara->writeptr = pwrite;
    
  return(0);
}

/*----------------------------------------------------------------------------+
|  demux_filter_set_readptr
+-----------------------------------------------------------------------------+
|  DESCRIPTION: This function sets the read pointer for the specified demux 
|  queue.  
+----------------------------------------------------------------------------*/
static int demux_filter_set_readptr(
   struct file      *file,
   GLOBAL_RESOURCES *pGlobal,
   DEMUX_FILTER     *pDmxfilter,
   ULONG            rp)

{
  QUEUE_PTR pQue;     /* channel information          */
  int flag;

  PDEBUG1("demux_filter_set_readptr(): Entering\n");
  
  if (!pDmxfilter || pDmxfilter->states < FILTER_STAT_START) 
  {
    printk("demux_filter_set_readptr(): filter not started");
    return(-EINVAL);
  }
    
  if(pDmxfilter->chid == ILLEGAL_CHANNEL)
  {
    printk("demux_filter_set_readptr(): ILLEGAL CHANNEL");
    return(-EINVAL);
  }
    
  if((pDmxfilter->flags & FILTER_FLAG_UNBUFFERED) == 0)
  {
    printk("demux_filter_get_queue(): filter not in unbuffered mode");
    return(-EINVAL);
  }

  pQue = &pGlobal->QueueInfo.XpQueueChData[pDmxfilter->chid];
  if(pQue->hMem == 0)
  {
    printk("demux_filter_set_readptr(): queue not allocated");
    return(-EINVAL);
  }
  
  if(rp > pQue->ulQueueSize)
  {
    printk("demux_filter_set_readptr(): read pointer outside of queue\n");
    return(-EINVAL);
  }
  
  if(rp == pQue->ulQueueSize)
    pDmxfilter->buffer.ulRead = 0;
  else
    pDmxfilter->buffer.ulRead = rp;
    
  if(rp == 0)
    rp = pQue->ulQueueSize;
    
  rp = (rp+pQue->ulQueueAddr) & 0x00ffff00;
 
  flag = os_enter_critical_section();
  pQue->ppReadAddr = (void *)(rp + pQue->ulQueueAddr);
  xp_atom_dcr_write_register_channel(pGlobal->uDeviceIndex,XP_QCONFIGB_REG_RPTR, 
                                     pDmxfilter->chid, rp);

  os_leave_critical_section(flag);
  
  return(0);
}

/*----------------------------------------------------------------------------+
|  DemuxFilterSetFlags
+----------------------------------------------------------------------------*/
int DemuxFilterSetFlags(
   GLOBAL_RESOURCES *pGlobal,
   DEMUX_FILTER     *pDmxfilter,
   int flags)
{

  if(flags & FILTER_FLAG_NONBUFFERED)
    pDmxfilter->flags |= FILTER_FLAG_UNBUFFERED;
  return(0);
}

/*----------------------------------------------------------------------------+
|   XX     XXXXXX    XXXXXX    XXXXX
|  XXXX    XX   XX     XX     XX   XX
| XX  XX   XX   XX     XX      XX
| XX  XX   XXXXX       XX        XX
| XXXXXX   XX          XX         XX
| XX  XX   XX          XX     XX   XX
| XX  XX   XX        XXXXXX    XXXXX
+----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------+
|  demux_filter_open
+-----------------------------------------------------------------------------+
|  DESCRIPTION: This Function will init the demux hardware and return a
|               filter handler.
+----------------------------------------------------------------------------*/
int demux_filter_open(
   DEMUX_DEVICE *pDemuxDev,
   UINT         uDeviceIndex,
   struct inode *inode,
   struct file  *filp)

{
   int i;
   int rc;
   GLOBAL_RESOURCES *pGlobal;
   DEMUX_FILTER     *pDmxfilter;


   PDEBUG("demux_filter_open(): Entering\n");

   //If the hardware hasn't been initilized, init it
   if (uAlreadyInit == 0)
   {
      for(i = 0; i < MAX_XP_NUM; i++)
      {
         XpGlobal[i].uDeviceIndex = i;
         pDemux_dev[i] = NULL;
      }

      uAlreadyInit++;
      hMutex = os_create_mut