tw2880.c

tw2880的初始化配置

                                }
                                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("\ttw2815b_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;
                      }
                      tw2815_set_ada_playback_samplerate(TW2815B_I2C_ADDR,SERIAL_CONTROL,samplerate);
                        break;

             case TW2815_GET_ADA_SAMPLERATE:
				ada_samplerate= tw2815_byte_read(TW2815B_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("\ttw2815b_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(TW2815B_I2C_ADDR,SERIAL_CONTROL,bitwidth);
                      break;

                   case TW2815_GET_ADA_BITWIDTH:
				ada_bitwidth = tw2815_byte_read(TW2815B_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("\ttw2815b_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(TW2815B_I2C_ADDR,SERIAL_CONTROL,bitrate);
                   break;
           case TW2815_GET_ADA_BITRATE:
		                ada_bitrate = tw2815_byte_read(TW2815B_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("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_D1_FAIL;
                }
                setd1(TW2815B_I2C_ADDR);
                break;
                
             case TW2815_SET_2_D1:
                if (copy_from_user(&tw2815_2d1, argp,sizeof(tw2815_2d1)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_2_D1_FAIL;
                }
                set_2_d1(TW2815B_I2C_ADDR,tw2815_2d1.ch1,tw2815_2d1.ch2);
                break;
                
             case TW2815_SET_4HALF_D1:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_4HALF_D1_FAIL;
                }
                set_4half_d1(TW2815B_I2C_ADDR,tmp);
                break;
                
             case TW2815_SET_4_CIF: 
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_4_CIF_FAIL;
                }
                set_4cif(TW2815B_I2C_ADDR,tmp);
                break;
                
             case  TW2815_SET_AUDIO_OUTPUT:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_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(TW2815B_I2C_ADDR,tmp);
                break;
                
             case TW2815_GET_AUDIO_OUTPUT:
                 tmp = tw2815_byte_read(TW2815B_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("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_AUDIO_MIX_OUT_FAIL;
                }
                set_audio_mix_out(TW2815B_I2C_ADDR,tmp);
                break;
                
             case TW2815_SET_AUDIO_RECORD_M:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_AUDIO_RECORD_M_FAIL;
                }
                set_audio_record_m(TW2815B_I2C_ADDR,tmp);
                break;
                
             case TW2815_SET_MIX_MUTE:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_MIX_MUTE_FAIL;
                }
		if(tmp<0||tmp>4)
                {
                  printk("TW2815B_SET_MIX_MUTE_FAIL\n");
                   return TW2815_SET_MIX_MUTE_FAIL;
                }

                set_audio_mix_mute(TW2815B_I2C_ADDR,tmp);
                break;
                
             case TW2815_CLEAR_MIX_MUTE:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_CLEAR_MIX_MUTE_FAIL;
                }
		 if(tmp<0||tmp>4)
                {
                   printk("TW2815B_CLEAR_MIX_MUTE_FAIL\n");
                   return TW2815_CLEAR_MIX_MUTE_FAIL;
                }

                clear_audio_mix_mute(TW2815B_I2C_ADDR,tmp);
                break;

             case TW2815_SET_VIDEO_MODE:
                 if (copy_from_user(&tw2815_videomode, argp, sizeof(tw2815_videomode)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tw2815_videomode.mode);
                    return TW2815_SET_VIDEO_MODE_FAIL;
                }
                if((tw2815_videomode.mode != NTSC)&&(tw2815_videomode.mode !=PAL)&&(tw2815_videomode.mode !=AUTOMATICALLY))
                {
                        printk("set video mode %d error\n ",tw2815_videomode.mode);
                        return TW2815_SET_VIDEO_MODE_FAIL;
                }
                tw2815_video_mode_init(TW2815B_I2C_ADDR,tw2815_videomode.mode,tw2815_videomode.ch);
               break;
             case TW2815_GET_VIDEO_MODE:
              
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_VIDEO_MODE_FAIL;
                }
	#if 0
              tmp_help = tw2815_byte_read(TW2815B_I2C_ADDR,tmp*0x10+0x1);
	      CLEAR_BIT(tmp_help,0x80);
	      tw2815_byte_write(TW2815B_I2C_ADDR,tmp*0x10+0x01,tmp_help);
	#endif    
	       tmp_help = (tw2815_byte_read(TW2815B_I2C_ADDR,tmp*0x10+0x0))>>5;
	      if(tmp_help <= 3)
	      	{
	      		tmp = PAL;
	      	}
	      else
	      	{
	      		tmp = NTSC;
	      	}
                copy_to_user(argp,&tmp,sizeof(tmp));
		break;
             case TW2815_REG_DUMP:
             tw2815_reg_dump(TW2815B_I2C_ADDR);
	    break;
             case TW2815_SET_CHANNEL_SEQUENCE:
             if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_CHANNEL_SEQUENCE_FAIL;
                }
                if((tmp>2)||(tmp<0))
                return TW2815_SET_CHANNEL_SEQUENCE_FAIL;
                channel_alloc(TW2815B_I2C_ADDR,tmp);
             break;
            case TW2815_SET_AUDIO_CASCAD:
                if (copy_from_user(&tmp, argp, sizeof(tmp)))
                {
                    printk("\ttw2815a_ERROR: WRONG cpy tmp is %x\n",tmp);
                    return TW2815_SET_AUDIO_CASCAD_FAIL;
                }
                if(tmp==SET_AUDIO_CASCAD)
                {
                    set_audio_cascad();
                }
                else if(tmp == SET_AUDIO_SINGLE)
                {
                    set_single_chip();
                }
                else
		return TW2815_SET_AUDIO_CASCAD_FAIL;
	    break;
            case TW2815_HUE_CONTROL:
                if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_HUE_CONTROL_FAIL;
                } 
                hue_control(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,tw2815_controlvalue.controlvalue);
                break;
                case TW2815_GET_HUE_SET:
                 if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_GET_HUE_SET_FAIL;
                }
                 hue_control_get(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,&tw2815_controlvalue.controlvalue);
                copy_to_user(argp,&tw2815_controlvalue, sizeof(tw2815_controlvalue));
                case TW2815_SATURATION_CONTROL:
                 if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_SATURATION_CONTROL_FAIL;
                } 
                saturation_control(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,tw2815_controlvalue.controlvalue); 
                break;
                case TW2815_GET_SATURATION_SET:
                 if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_GET_SATURATION_SET_FAIL;
                }
                 saturation_control_get(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,&tw2815_controlvalue.controlvalue);
                copy_to_user(argp,&tw2815_controlvalue, sizeof(tw2815_controlvalue));
                break; 
                case TW2815_CONTRAST_CONTROL:
                  if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_CONTRAST_CONTROL_FAIL;
                }
                contrast_control(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,tw2815_controlvalue.controlvalue);

                break;
                case TW2815_GET_CONTRAST_SET:
                 if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_GET_CONTRAST_SET_FAIL;
                }
                contrast_control_get(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,&tw2815_controlvalue.controlvalue);
                copy_to_user(argp,&tw2815_controlvalue, sizeof(tw2815_controlvalue));
                break;

                case TW2815_BRIGHTNESS_CONTROL:
                   if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_BRIGHTNESS_CONTROL_FAIL;
                }
                   brightness_control(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,tw2815_controlvalue.controlvalue);
                break;
                case TW2815_GET_BRIGHTNESS_SET:
                 if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_GET_BRIGHTNESS_SET_FAIL;
                }
                   brightness_control_get(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,&tw2815_controlvalue.controlvalue);
                copy_to_user(argp,&tw2815_controlvalue, sizeof(tw2815_controlvalue));
                   break; 
                case TW2815_LUMINANCE_PEAKING_CONTROL:
                    if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {
                      printk("\ttw2815b_ERROR: WRONG cpy tmp is %x\n",tmp);
                      return TW2815_LUMINANCE_PEAKING_FAIL;
                }
                    if(0 != luminance_peaking_control(TW2815B_I2C_ADDR,tw2815_controlvalue.ch,tw2815_controlvalue.controlvalue))
                    {
                        return TW2815_LUMINANCE_PEAKING_FAIL;
                    }

                break;
                case TW2815_GET_LUMINANCE_PEAKING_SET:
                   if (copy_from_user(&tw2815_controlvalue, argp, sizeof(tw2815_controlvalue)))
                {