Пример #1
0
static int labx_dma_ioctl_cdev(struct inode *inode,
                               struct file *filp,
                               unsigned int command, unsigned long arg) {
    struct labx_dma_pdev *dma_pdev = (struct labx_dma_pdev*)filp->private_data;

    return labx_dma_ioctl(&dma_pdev->dma, command, arg);
}
Пример #2
0
static int labx_local_audio_ioctl_cdev(struct inode *inode, struct file *filp,
                                       unsigned int command, unsigned long arg)
{
  struct labx_local_audio_pdev *local_audio_pdev = (struct labx_local_audio_pdev*)filp->private_data;
  int returnValue = 0;

  switch(command) {
  case IOC_LA_SET_CHANNEL_MAPPING:
    {
      struct LocalAudioChannelMapping mapping;
      if(copy_from_user(&mapping, (void __user*)arg, sizeof(mapping)) != 0) {
        printk("CFU failed\n");
        return(-EFAULT);
      }
			
      if (mapping.channel >= local_audio_pdev->numChannels) {
        printk("Channel check failed: %d, %d\n", mapping.channel, local_audio_pdev->numChannels);
        return(-EINVAL);
      }

      XIo_Out32(LOCAL_AUDIO_REGISTER_BASE(local_audio_pdev, LOCAL_AUDIO_CHANNEL_REG + mapping.channel),
                mapping.streams);
    }
    break;

  case IOC_LA_GET_CHANNEL_MAPPING:
    {
      struct LocalAudioChannelMapping mapping;

      if(copy_from_user(&mapping, (void __user*)arg, sizeof(mapping)) != 0) {
        return(-EFAULT);
      }
			
      if (mapping.channel >= local_audio_pdev->numChannels) {
        return(-EINVAL);
      }
			
      mapping.streams = XIo_In32(LOCAL_AUDIO_REGISTER_BASE(local_audio_pdev, LOCAL_AUDIO_CHANNEL_REG + mapping.channel));

      if(copy_to_user(&mapping, (void __user*)arg, sizeof(mapping)) != 0) {
        return(-EFAULT);
      }
    }
    break;

  case IOC_LA_SET_INSERT_MODE:
    {
      struct LocalAudioInsertConfig config;
      uint32_t value = 0;

      if(copy_from_user(&config, (void __user*)arg, sizeof(config)) != 0) {
        return(-EFAULT);
      }

      switch(config.mode)
        {
        default:
          return(-EINVAL);

        case LA_INSERT_MODE_OFF:
          break;

        case LA_INSERT_MODE_ZERO:
          value = LOCAL_AUDIO_INSERTER_ENABLE | LOCAL_AUDIO_INSERTER_ZERO;
          break;

        case LA_INSERT_MODE_DC:
          value = LOCAL_AUDIO_INSERTER_ENABLE | LOCAL_AUDIO_INSERTER_DC;
          break;

        case LA_INSERT_MODE_RAMP:
          value = LOCAL_AUDIO_INSERTER_ENABLE | LOCAL_AUDIO_INSERTER_RAMP;
          break;

        case LA_INSERT_MODE_LFSR:
          value = LOCAL_AUDIO_INSERTER_ENABLE;
          break;
        }

      value |= (config.stream << LOCAL_AUDIO_INSERTER_STREAM_SHIFT) & LOCAL_AUDIO_INSERTER_STREAM_MASK;
      value |= (config.slot << LOCAL_AUDIO_INSERTER_SLOT_SHIFT) & LOCAL_AUDIO_INSERTER_SLOT_MASK;
      
      XIo_Out32(LOCAL_AUDIO_INSERTER_BASE(local_audio_pdev, LOCAL_AUDIO_INSERTER_TDM_CTRL_REG),
                value);
    }
    break;

  default:
    /* We don't recognize this command; first give an encapsulated DMA controller
     * a crack at it (if one exists), and then our derived driver (if one exists).
     */
    if(local_audio_pdev->dma != NULL) returnValue = labx_dma_ioctl(local_audio_pdev->dma, command, arg);
    if(((local_audio_pdev->dma == NULL) | (returnValue == -EINVAL)) &&
       (local_audio_pdev->derivedFops != NULL) && 
       (local_audio_pdev->derivedFops->ioctl != NULL)) {
      returnValue = local_audio_pdev->derivedFops->ioctl(inode, filp, command, arg);
    }
    return(returnValue);
  }

  /* Command handled locally without incident, return success */
  return(0);
}