tw2880.c

tw2880的初始化配置

    }
    temp = tw2815_byte_read(chip_addr,ch*0x10+0xc);
    CLEAR_BIT(temp,0xf);
    SET_BIT(temp,cti_value);
    tw2815_byte_write(chip_addr,ch*0x10+0xc,temp);
    return 0;
}
static void cti_control_get(unsigned char chip_addr,unsigned char ch ,unsigned int *cti_value)
{
     *cti_value = (tw2815_byte_read(chip_addr,ch*0x10+0xc)&0x0f);
}
/*
 * tw2815a read routine.
 * do nothing.
 */
ssize_t tw2815a_read(struct file * file, char __user * buf, size_t count, loff_t * offset)
{
    return 0;
}

/*
 * tw2815a write routine.
 * do nothing.
 */
ssize_t tw2815a_write(struct file * file, const char __user * buf, size_t count, loff_t * offset)
{
    return 0;
}

/*
 * tw2834 open routine.
 * do nothing.
 */
 
 int tw2815a_open(struct inode * inode, struct file * file)
{
#if 0
   if(tw2815a_dev_open_cnt)
   {
   	printk("error tw2815adev had open\n");
        return -EFAULT;        
   }	
   tw2815a_dev_open_cnt++;
    if(DEBUG_2815)
    {
    	printk("tw2815a_dev open ok\n");
    }	
#endif    
    return 0;
} 
/*
 * tw2815a close routine.
 * do nothing.
 */
int tw2815a_close(struct inode * inode, struct file * file)
{
    tw2815a_dev_open_cnt--;	
    return 0;
}

Tw2815Ret tw2815a_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    unsigned int __user *argp = (unsigned int __user *)arg;
    unsigned int tmp,tmp_help,samplerate,ada_samplerate,bitwidth,ada_bitwidth,bitrate,ada_bitrate;
    tw2815_w_reg tw2815reg;
    tw2815_set_2d1 tw2815_2d1;
    tw2815_set_videomode tw2815_videomode;
    tw2815_set_controlvalue tw2815_controlvalue;
    switch(cmd)
            {
            case TW2815_READ_REG:
                if (copy_from_user(&tmp_help, argp, sizeof(tmp_help)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_READ_REG_FAIL;
                }
                tmp = tw2815_byte_read(TW2815A_I2C_ADDR,(u8)tmp_help);
                copy_to_user(argp, &tmp, sizeof(tmp));
                break;
            case TW2815_WRITE_REG:
                if (copy_from_user(&tw2815reg, argp, sizeof(tw2815reg)))
                {
                    printk("ttw2815a_ERROR");
                    return TW2815_WRITE_REG_FAIL;
                }
                tw2815_byte_write(TW2815A_I2C_ADDR,(u8)tw2815reg.addr,(u8)tw2815reg.value);
                break;
     
            
	     case TW2815_SET_ADA_PLAYBACK_SAMPLERATE :
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_ADA_PLAYBACK_SAMPLERATE_FAIL;
                }    
                     samplerate = tmp;
                     tw2815_set_ada_playback_samplerate(TW2815A_I2C_ADDR,SERIAL_PLAYBACK_CONTROL,samplerate);    
                        break;
                        
                        
	    case TW2815_GET_ADA_PLAYBACK_SAMPLERATE :
				ada_samplerate = tw2815_byte_read(TW2815A_I2C_ADDR,SERIAL_PLAYBACK_CONTROL);
				if((ada_samplerate & 0x04)==0x04)
			        {
                                    ada_samplerate = SET_16K_SAMPLERATE;
                                }
                                else
                                {
                                    ada_samplerate = SET_8K_SAMPLERATE;
                                }
                                copy_to_user(argp,&ada_samplerate,sizeof(ada_samplerate));
				break;
				
            case TW2815_SET_ADA_PLAYBACK_BITWIDTH:
                 if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_ADA_PLAYBACK_BITWIDTH_FAIL;
                }      
                        bitwidth = tmp;
                 tw2815_set_ada_playback_bitwidth(TW2815A_I2C_ADDR,SERIAL_PLAYBACK_CONTROL,bitwidth);             
                        break;


             case TW2815_GET_ADA_PLAYBACK_BITWIDTH :
				ada_bitwidth = tw2815_byte_read(TW2815A_I2C_ADDR,SERIAL_PLAYBACK_CONTROL);
				if((ada_bitwidth & 0x02)==0x02)
			        {
                                    ada_bitwidth = SET_8_BITWIDTH;
                                }
                                else
                                {
                                    ada_bitwidth = SET_16_BITWIDTH;
                                }
                                copy_to_user(argp,&ada_bitwidth,sizeof(ada_bitwidth));
				break;


				
            case TW2815_SET_ADA_PLAYBACK_BITRATE:
                 if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_ADA_PLAYBACK_BITRATE_FAIL;
                }       
                        bitrate= tmp;
                        tw2815_set_ada_playback_bitrate(TW2815A_I2C_ADDR,SERIAL_PLAYBACK_CONTROL,bitrate);
                        break;

              case TW2815_GET_ADA_PLAYBACK_BITRATE:
				ada_bitrate = tw2815_byte_read(TW2815A_I2C_ADDR,SERIAL_PLAYBACK_CONTROL);
				if((ada_bitrate & 0x10)==0x10)
                                {
                                    ada_bitrate = SET_384_BITRATE;
                                }
                                else
                                {
                                    ada_bitrate = SET_256_BITRATE;
                                }
                                copy_to_user(argp,&ada_bitrate,sizeof(ada_bitrate));
				break;          


           case TW2815_SET_ADA_SAMPLERATE :
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_ADA_SAMPLERATE_FAIL;
                }        
                      samplerate = tmp;
                      if((tmp !=SET_8K_SAMPLERATE)&&(tmp !=SET_16K_SAMPLERATE))
                      {
                      	        return 	TW2815_SET_ADA_SAMPLERATE_FAIL;
                      }
			printk("samplerate = %d\n",samplerate);
                      tw2815_set_ada_playback_samplerate(TW2815A_I2C_ADDR,SERIAL_CONTROL,samplerate);
                      
                      break;


             case TW2815_GET_ADA_SAMPLERATE:
				ada_samplerate= tw2815_byte_read(TW2815A_I2C_ADDR,SERIAL_CONTROL);
				if((ada_samplerate & 0x04)==0x04)
                                {
                                    ada_samplerate = SET_16K_SAMPLERATE;
                                }
                                else
                                {
                                    ada_samplerate = SET_8K_SAMPLERATE;
                                }
                                copy_to_user(argp,&ada_samplerate,sizeof(ada_samplerate));
				break;               
                        
             case TW2815_SET_ADA_BITWIDTH:
               if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_ADA_BITWIDTH_FAIL;
                }                    
                      bitwidth = tmp;
                      if(bitwidth == SET_8_BITWIDTH)
                      {
                      	   set_audio_cascad();
                      }
                      else if(bitwidth == SET_16_BITWIDTH)
                      {
                      	   set_single_chip();		
                      }
                      else
                      {
                      	   return TW2815_SET_ADA_BITWIDTH_FAIL;
                      }
                      tw2815_set_ada_playback_bitwidth(TW2815A_I2C_ADDR,SERIAL_CONTROL,bitwidth);
                      break;

                   case TW2815_GET_ADA_BITWIDTH:
				ada_bitwidth = tw2815_byte_read(TW2815A_I2C_ADDR,SERIAL_CONTROL);
				if((ada_bitwidth & 0x02)==0x02)
                                {
                                    ada_bitwidth = SET_8_BITWIDTH;
                                }
                                else
                                {
                                    ada_bitwidth = SET_16_BITWIDTH;
                                }
                                copy_to_user(argp,&ada_bitwidth,sizeof(ada_bitwidth));
				break;      
				
            case TW2815_SET_ADA_BITRATE:
             if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_ADA_BITRATE_FAIL;
                }                       
                      bitrate= tmp;
                      if((tmp !=SET_256_BITRATE)&&(tmp !=SET_384_BITRATE))
                      {
                      		return TW2815_SET_ADA_BITRATE_FAIL;
                      }	
                      tw2815_set_ada_playback_bitrate(TW2815A_I2C_ADDR,SERIAL_CONTROL,bitrate);
                     break;
           case TW2815_GET_ADA_BITRATE:
		            ada_bitrate = tw2815_byte_read(TW2815A_I2C_ADDR,SERIAL_CONTROL);
				if((ada_bitrate & 0x10)==0x10)
                                {
                                    ada_bitrate = SET_384_BITRATE;
                                }
                                else
                                {
                                    ada_bitrate = SET_256_BITRATE;
                                }
                                copy_to_user(argp,&ada_bitrate,sizeof(ada_bitrate));
				break;     

				
             case TW2815_SET_D1:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_D1_FAIL;
                    
                }
                setd1(TW2815A_I2C_ADDR);
               break;
                
             case TW2815_SET_2_D1:
                
                if (copy_from_user(&tw2815_2d1, argp, sizeof(tw2815_2d1)))
                {
                    return TW2815_SET_2_D1_FAIL;
                }
                set_2_d1(TW2815A_I2C_ADDR,tw2815_2d1.ch1,tw2815_2d1.ch2);
                break;
                
             case TW2815_SET_4HALF_D1:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_4HALF_D1_FAIL;
                }
                set_4half_d1(TW2815A_I2C_ADDR,tmp);
                break;
                
             case TW2815_SET_4_CIF:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_4_CIF_FAIL;
                    
                } 
                set_4cif(TW2815A_I2C_ADDR,tmp);
                break;
                
             case  TW2815_SET_AUDIO_OUTPUT:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_AUDIO_OUTPUT_FAIL;
                }
                if((tmp<=0)||(tmp>16))
                {
                	return TW2815_SET_AUDIO_OUTPUT_FAIL;
                }
                set_audio_output(TW2815A_I2C_ADDR,tmp);
                
                break;
                
             case TW2815_GET_AUDIO_OUTPUT:
                 tmp = tw2815_byte_read(TW2815A_I2C_ADDR,0x63);
                 if((tmp & 0x03)==0x0)
                 {
                     tmp_help = 2;
                 }
                 else if((tmp & 0x03)==0x1)
                 {
                     tmp_help =4;
                 }
                 else if((tmp & 0x03)==0x2)
                 {
                     tmp_help =8;
                 }
                 else if((tmp & 0x03)==0x3)
                 {
                     tmp_help =16;
                 }
                 copy_to_user(argp,&tmp_help,sizeof(tmp_help));
                
               break; 
             case  TW2815_SET_AUDIO_MIX_OUT:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_AUDIO_MIX_OUT_FAIL;
                }
                set_audio_mix_out(TW2815A_I2C_ADDR,tmp);
                break;
                
             case TW2815_SET_AUDIO_RECORD_M:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_AUDIO_RECORD_M_FAIL;
                }
                set_audio_record_m(TW2815A_I2C_ADDR,tmp);
                break;
                
             case TW2815_SET_MIX_MUTE:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_MIX_MUTE_FAIL;
                }
		if(tmp<0||tmp>4)
		{
	          printk("TW2815A_SET_MIX_MUTE_FAIL\n");
		   return TW2815_SET_MIX_MUTE_FAIL;
		}  
                set_audio_mix_mute(TW2815A_I2C_ADDR,tmp);
                break;
                
             case TW2815_CLEAR_MIX_MUTE:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_CLEAR_MIX_MUTE_FAIL;