aud_inf.c

IBM source for pallas/vulcan/vesta

                {
                    ret = 0;
                    goto SetSource;
                }
                if(ioctl_param == 1)
                {
                    aud_osi_close_tv();
                    //aud_inf_init_main();
                    ret = aud_osd_init_clip(&_adec_main);
                    goto SetSource;
                }
            }
            if(_src == 1)
            {
                if(ioctl_param == 1)
                {
                    ret = 0;
                    goto SetSource;
                }
                if(ioctl_param == 0)
                {
                    aud_osd_close_clip(&_adec_main);
                    ret = aud_osi_init_tv();
                    goto SetSource;
                }
            }
SetSource:  if(ret == 0)
                _src = ioctl_param;
            break;

           case MPEG_AUD_SELECT_CHANNEL:
                    ret = aud_osi_set_channel(ioctl_param);
                        break;
       case MPEG_AUD_GET_BUF_NOWAIT:
            PDEBUG("GET BUF NOWAIT\n");
            if(minor == DRV_MINOR_AUD_MIXER)
            {
                if(_adec_mixer.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                
                ret = aud_osd_get_buf_nowait(&_adec_mixer, (CLIPINFO*)ioctl_param);
            }
            else
            {
                if(_adec_main.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                ret = aud_osd_get_buf_nowait(&_adec_main, (CLIPINFO*)ioctl_param);
            }
            break;

        case MPEG_AUD_GET_BUF_WAIT:
            PDEBUG("GET BUF WAIT\n");
            if(minor == DRV_MINOR_AUD_MIXER)
            {
                if(_adec_mixer.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                
                ret = aud_osd_get_buf_wait(&_adec_mixer, (CLIPINFO*)ioctl_param);
            }
            else
            {
                if(_adec_main.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                ret = aud_osd_get_buf_wait(&_adec_main, (CLIPINFO*)ioctl_param);
            }
            break;

        case MPEG_AUD_CLIP_WRITE:
            PDEBUG("CLIP WRITE\n");
            if(minor == DRV_MINOR_AUD_MIXER)
            {
                if(_adec_mixer.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                
                ret = aud_osd_clip_write(&_adec_mixer, (CLIPINFO*)ioctl_param);
            }
            else
            {
                if(_adec_main.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                ret = aud_osd_clip_write(&_adec_main, (CLIPINFO*)ioctl_param);
            }
            break;
        case MPEG_AUD_GET_BUF_SIZE:
            PDEBUG("AUDIO get buffer size\n");
            if(minor == DRV_MINOR_AUD_MIXER)
            {
                *((unsigned long*)ioctl_param) = MPEG_A_MIXER_BUF_LEN;
            }
            else
                *((unsigned long*)ioctl_param) = MPEG_A_CLIP_BUF_LEN;
            break;
        case MPEG_AUD_END_OF_STREAM:
            PDEBUG("END OF STREAM\n");
            if(minor == DRV_MINOR_AUD_MIXER)
            {
                ret = aud_osd_end_stream(&_adec_mixer);
            }
            else
                ret = aud_osd_end_stream(&_adec_main);
            break;

        case MPEG_AUD_SET_PCM_FORMAT:
            {
                 AUD_PCM_FORMAT_CONFIG pcmcfg;

                 PDEBUG("PCM format\n");
                 copy_from_user(&pcmcfg, (AUD_PCM_FORMAT_CONFIG*)ioctl_param, sizeof(pcmcfg));

                 if(minor == DRV_MINOR_AUD_MIXER)
                 {
                    PDEBUG("set mixer fmt\n");
                    ret = aud_osi_set_mixer_fmt((AUD_PCM_FORMAT_CONFIG*)&pcmcfg);
                 }
                 else
                 {
                     PDEBUG("set main pcm fmt\n");
                     ret = aud_osi_set_pcm_fmt((AUD_PCM_FORMAT_CONFIG*)&pcmcfg);
                 }
                         break;
            }
        case MPEG_AUD_SET_VOL:
            {
                AUDVOL vol;
                
                copy_from_user((void*)&vol, (void*)ioctl_param, sizeof(AUDVOL));
                if(minor == DRV_MINOR_AUD_MIXER)
                {   
                    ret = aud_osi_set_mixer_vol(&vol);
                }
                else
                    ret = aud_osi_set_vol(&vol);
                break;
            }
        case MPEG_AUD_GET_VOL:
            {
                AUDVOL vol;
                if(minor == DRV_MINOR_AUD_MIXER)
                {
                    if(aud_osi_get_mixer_vol(&vol) != 0)
                    {
                        ret = -1;
                        break;
                    }
                }
                else
                {
                    if(aud_osi_get_vol(&vol) != 0)
                    {
                        ret = -1;
                        break;
                    }
                }
                copy_to_user((void*)ioctl_param, (void*)&vol, sizeof(AUDVOL));
                ret = 0;
                break;
            }
                
        case MPEG_AUD_GET_SYNC_INFO:
            {
                STC_T stc, pts;

                if(minor == DRV_MINOR_AUD_MIXER)
                {
                    PDEBUG("not support in mixer\n");
                    return -1;
                }
                aud_osi_get_stc(&stc);
                aud_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_AUD_SET_SYNC_STC:
            {
                STC_T stc;

                if(minor == DRV_MINOR_AUD_MIXER)
                {
                    PDEBUG("not support in mixer\n");
                    return -1;
                }
                copy_from_user(&stc, &(((SYNCINFO*)ioctl_param)->stc), sizeof(STC_T));
                aud_osi_set_stc(&stc);

                break;
            }
        case MPEG_AUD_SYNC_ON:
            ret = aud_osi_enable_sync(ioctl_param);
            break;
        case MPEG_AUD_SYNC_OFF:
            ret = aud_osi_disable_sync();
            break;
        case MPEG_AUD_RESET_CLIPBUF:
            ret = aud_osi_reset_clipbuf(&_adec_main);
            break;
        case MPEG_AUD_GET_STATUS:
            ret = aud_osi_get_status(&aud_stat);
            copy_to_user ((audioStatus *)ioctl_param, &aud_stat, sizeof(audioStatus));
            break;
        case MPEG_AUD_CLIP_FLUSH:
            if(minor == DRV_MINOR_AUD_MIXER)
            {
                if(_adec_mixer.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                
                ret = aud_osi_clip_flush(_adec_mixer.clipdev);
            }
            else
            {
                if(_adec_main.uMapped == 0)
                {
                    PDEBUG("physical memory not mapped\n");
                    ret = -1;
                    break;
                }
                ret = aud_osi_clip_flush(_adec_main.clipdev);
            }
            break;
        default:
            ret = -1;
            break;           
    }
    return ret;
}

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

static struct file_operations Fops = {
    read:   aud_inf_read,
    write:  aud_inf_write,
    ioctl:  aud_inf_ioctl,
    open:   aud_inf_open,
    release:aud_inf_release,
    poll:   aud_inf_poll,
    mmap:   aud_inf_mmap 
};


static struct {
                char *name;
		int minor;
		struct file_operations *fops;
		devfs_handle_t devfs_handle;
              } devnodes[] = { 
			                  {DEVICE_NAME_ADEC,0,&Fops,0},
					  {"adec_mpg",0,&Fops,0},
					  {"aud_mpeg",0,&Fops,0},
					  {"adec_ac3",1,&Fops,0},
					  {"adec_pcm",2,&Fops,0},
					  {"adec_mixer",3,&Fops,0},
					  {"adec_dts",4,&Fops,0},
					  {"adec_lpcm",5,&Fops,0}
				       };

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

/* Initialize the module - Register the character device */
int aud_init_module()
{
    int ret_val;
    int *ver;
    struct aud_ucode_info **uc_ptr;
    devfs_handle_t devfs_handle;
    int i;

    /* Register the character device (atleast try) */
    ret_val = devfs_register_chrdev(MAJOR_NUM_ADEC, DEVICE_NAME_ADEC, &Fops);
    /* Negative values signify an error */
    if (ret_val < 0)
    {
        PDEBUG("AUD: %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_ADEC, 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;
      }
    }
    

    /* print version numbers for audio microcode */
    for (uc_ptr = aud_ucode_info; *uc_ptr != NULL; uc_ptr++) {
      if (((*uc_ptr)->ucode[248] != 0) || ((*uc_ptr)->ucode[249] != 0)) {
	ver = (int *)(&(*uc_ptr)->ucode[248]);
	printk(KERN_NOTICE "audio microcode %s **test version** built on %d/%d/%d\n", 
	       (*uc_ptr)->name, (*ver%10000)/100, *ver%100, *ver/10000);
      } else {
	printk(KERN_NOTICE "audio microcode %s ver %d.%d\n", (*uc_ptr)->name,
	       (*uc_ptr)->ucode[250], (*uc_ptr)->ucode[251]);
      }
    }

    //DEMUX_REG_AVCB(&aud_callback, 1, 1);
    PDEBUG("AUD: Initialize adec_dev OK!\n");
    return 0;
}

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

    /* Unregister the device */
    ret = devfs_unregister_chrdev(MAJOR_NUM_ADEC, DEVICE_NAME_ADEC);
    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);

    }

}