s3c2410-uda1341.c

2410开发板上的声卡驱动！网上收集！很全的啊！1341型号

				break;
                }
        }


	if (file->f_mode & FMODE_WRITE) {
		if (!output_stream.buffers && audio_setup_buf(&output_stream))
			return -ENOMEM;
		poll_wait(file, &output_stream.buf->sem.wait, wait);

		for (i = 0; i < output_stream.nbfrags; i++) {
			if (atomic_read(&output_stream.buffers[i].sem.count) > 0)
				mask |= POLLOUT | POLLWRNORM;
				break;
		}
	}

	DPRINTK("audio_poll() returned mask of %s\n",
		(mask & POLLOUT) ? "w" : "");

	return mask;
}


static loff_t smdk2410_audio_llseek(struct file *file, loff_t offset, 
				    int origin)
{
            return -ESPIPE;
}


static int smdk2410_mixer_ioctl(struct inode *inode, struct file *file, 
                                unsigned int cmd, unsigned long arg)
{
        int ret;
        long val = 0;

	switch (cmd) {
		case SOUND_MIXER_INFO:
		{
			mixer_info info;
			strncpy(info.id, "UDA1341", sizeof(info.id));
			strncpy(info.name,"Philips UDA1341", sizeof(info.name));
			info.modify_counter = audio_mix_modcnt;
			return copy_to_user((void *)arg, &info, sizeof(info));
		}
	
		case SOUND_OLD_MIXER_INFO:
		{
			_old_mixer_info info;
			strncpy(info.id, "UDA1341", sizeof(info.id));
			strncpy(info.name,"Philips UDA1341", sizeof(info.name));
			return copy_to_user((void *)arg, &info, sizeof(info));
		}

		case SOUND_MIXER_READ_STEREODEVS:
			return put_user(0, (long *) arg);

		case SOUND_MIXER_READ_CAPS:
			val = SOUND_CAP_EXCL_INPUT;
			return put_user(val, (long *) arg);

		case SOUND_MIXER_WRITE_VOLUME:
			ret = get_user(val, (long *) arg);
			if (ret)
				return ret;
			uda1341_volume = 63 - (((val & 0xff) + 1) * 63) / 100;
			uda1341_l3_address(UDA1341_REG_DATA0);
			uda1341_l3_data(uda1341_volume);//用uda1341_volume 参数的值23（十进制）
			//将音量大小设置为总音量的65％；
			break;
		
		case SOUND_MIXER_READ_VOLUME:
			val = ((63 - uda1341_volume) * 100) / 63;
			val |= val << 8;
			return put_user(val, (long *) arg);
	
		case SOUND_MIXER_READ_IGAIN:
			val = ((31- mixer_igain) * 100) / 31;
			return put_user(val, (int *) arg);

		case SOUND_MIXER_WRITE_IGAIN:
			ret = get_user(val, (int *) arg);
			if (ret)
				return ret;
			mixer_igain = 31 - (val * 31 / 100);		
			/* use mixer gain channel 1*/
			uda1341_l3_address(UDA1341_REG_DATA0);
			uda1341_l3_data(EXTADDR(EXT0));
			uda1341_l3_data(EXTDATA(EXT0_CH1_GAIN(mixer_igain)));			
			break;

		default:
			DPRINTK("mixer ioctl %u unknown\n", cmd);
			return -ENOSYS;
	}			

	audio_mix_modcnt++;
	return 0;
}

static inline unsigned long cal_bus_clk(unsigned long cpu_clk, unsigned long ratio, int who)
{
	if (!who) {	/* PCLK */
		switch (ratio) {
			case 0:
				return (cpu_clk);
			case 1:
			case 2:
				return (cpu_clk/2);
			case 3:
				return (cpu_clk/4);
			default:
				return 0;
		}
	} else {	/* HCLK */
		switch (ratio) {
			case 0:
			case 1:
				return (cpu_clk);
			case 2:
			case 3:
				return (cpu_clk/2);
			default:
				return 0;
		}
	}
}


/*
 * cpu clock = (((mdiv + 8) * FIN) / ((pdiv + 2) * (1 << sdiv)))
 *  FIN = Input Frequency (to CPU)
 */
unsigned long s3c2410_get_cpu_clk(void)
{
	unsigned long val= __raw_readl(S3C2410_MPLLCON);
	
	return (((GET_MDIV(val) + 8) * FIN_NEW) / \
		((GET_PDIV(val) + 2) * (1 << GET_SDIV(val))));
}

unsigned long s3c2410_get_bus_clk(int who)
{
	unsigned long cpu_clk = s3c2410_get_cpu_clk();
	unsigned long ratio=__raw_readl(S3C2410_CLKDIVN);
	return (cal_bus_clk(cpu_clk, ratio, who));
}
static int iispsr_value(int s_bit_clock, int sample_rate)
{
        int i, prescaler = 0;
        unsigned long tmpval;
        unsigned long tmpval384;
        unsigned long tmpval384min = 0xffff;
 	
	tmpval384 = s3c2410_get_bus_clk(GET_PCLK_NEW) / s_bit_clock;

        for (i = 0; i < 32; i++) {
                tmpval = tmpval384/(i+1);
                if (PCM_ABS((sample_rate - tmpval)) < tmpval384min) {
                        tmpval384min = PCM_ABS((sample_rate - tmpval));
                        prescaler = i;
                }
        }

        DPRINTK("prescaler = %d\n", prescaler);

        return prescaler;
}

static long audio_set_dsp_speed(long val)
{
	switch (val) {
		case 48000:
		case 44100:
	 __raw_writel((IISPSR_A(iispsr_value(S_CLOCK_FREQ, 44100)) \
			| IISPSR_B(iispsr_value(S_CLOCK_FREQ, 44100))),S3C2410_SBC_IISPSR);
			break;
		case 22050:
	__raw_writel((IISPSR_A(iispsr_value(S_CLOCK_FREQ, 22050)) \
				| IISPSR_B(iispsr_value(S_CLOCK_FREQ, 22050))),S3C2410_SBC_IISPSR);
			break;
		case 11025:
	__raw_writel((IISPSR_A(iispsr_value(S_CLOCK_FREQ, 11025)) \
				| IISPSR_B(iispsr_value(S_CLOCK_FREQ, 11025))),S3C2410_SBC_IISPSR);
			break;
		case 8000:
	 __raw_writel( (IISPSR_A(iispsr_value(S_CLOCK_FREQ, 8000)) \
				| IISPSR_B(iispsr_value(S_CLOCK_FREQ, 8000))),S3C2410_SBC_IISPSR);
			break;
		default:
			return -1;
	}

	audio_rate = val;
	
	return audio_rate;
}

static int smdk2410_audio_ioctl(struct inode *inode, struct file *file, 
                                uint cmd, ulong arg)
{
	long val;

	switch (cmd) {
	  	case SNDCTL_DSP_SETFMT:
			get_user(val, (long *) arg);
		  	if (val & AUDIO_FMT_MASK) {
			    	audio_fmt = val;
			    	break;
		  	} else
				return -EINVAL;

	  	case SNDCTL_DSP_CHANNELS:
	  	case SNDCTL_DSP_STEREO:
		  	get_user(val, (long *) arg);
		  	if (cmd == SNDCTL_DSP_STEREO)
			  	val = val ? 2 : 1;
		  	if (val != 1 && val != 2)
			  	return -EINVAL;
		  	audio_channels = val;
		  	break;

	  	case SOUND_PCM_READ_CHANNELS:
		  	put_user(audio_channels, (long *) arg);
		 	break;

	  	case SNDCTL_DSP_SPEED:
		  	get_user(val, (long *) arg);
		  	val = audio_set_dsp_speed(val);
                        if (val < 0) 
				return -EINVAL;
		  	put_user(val, (long *) arg);
		  	break;

	  	case SOUND_PCM_READ_RATE:
		  	put_user(audio_rate, (long *) arg);
		  	break;

	  	case SNDCTL_DSP_GETFMTS:
		  	put_user(AUDIO_FMT_MASK, (long *) arg);
		  	break;

	  	case SNDCTL_DSP_GETBLKSIZE:
			if(file->f_mode & FMODE_WRITE)
		  		return put_user(audio_fragsize, (long *) arg);
			else		
				return put_user(audio_fragsize, (int *) arg);

	  	case SNDCTL_DSP_SETFRAGMENT:
		        if (file->f_mode & FMODE_WRITE) {	
		  		if (output_stream.buffers)
			  		return -EBUSY;
		  		get_user(val, (long *) arg);
		  		audio_fragsize = 1 << (val & 0xFFFF);
		  		if (audio_fragsize < 16)
			  		audio_fragsize = 16;
		  		if (audio_fragsize > 16384)
			  		audio_fragsize = 16384;
		  		audio_nbfrags = (val >> 16) & 0x7FFF;
				if (audio_nbfrags < 2)
					audio_nbfrags = 2;
		  		if (audio_nbfrags * audio_fragsize > 128 * 1024)
			  		audio_nbfrags = 128 * 1024 / audio_fragsize;
		  		if (audio_setup_buf(&output_stream))
			  		return -ENOMEM;
	
			}
			if (file->f_mode & FMODE_READ) {
				if (input_stream.buffers)
					return -EBUSY;
				get_user(val, (int *) arg);
				audio_fragsize =  1 << (val & 0xFFFF);
				if (audio_fragsize < 16)
					audio_fragsize = 16;
				if (audio_fragsize > 16384)
                                        audio_fragsize = 16384;
                                audio_nbfrags = (val >> 16) & 0x7FFF;
                                if (audio_nbfrags < 2)
                                        audio_nbfrags = 2;
                                if (audio_nbfrags * audio_fragsize > 128 * 1024)
                                        audio_nbfrags = 128 * 1024 / audio_fragsize;
                                if (audio_setup_buf(&input_stream))
                                        return -ENOMEM;

			}
		 	break;

	  	case SNDCTL_DSP_SYNC:
			return 0;
//GDLC		  	return audio_sync(file);

	  	case SNDCTL_DSP_GETOSPACE:
		{
			audio_stream_t *s = &output_stream;
			audio_buf_info *inf = (audio_buf_info *) arg;
			int err = verify_area(VERIFY_WRITE, inf, sizeof(*inf));
			int i;
			int frags = 0, bytes = 0;

			if (err)
				return err;
			for (i = 0; i < s->nbfrags; i++) {
				if (atomic_read(&s->buffers[i].sem.count) > 0) {
					if (s->buffers[i].size == 0) frags++;
					bytes += s->fragsize - s->buffers[i].size;
				}
			}
			put_user(frags, &inf->fragments);
			put_user(s->nbfrags, &inf->fragstotal);
			put_user(s->fragsize, &inf->fragsize);
			put_user(bytes, &inf->bytes);
			break;
		}

		case SNDCTL_DSP_GETISPACE:
		{
			audio_stream_t *s = &input_stream;
			audio_buf_info *inf = (audio_buf_info *) arg;
			int err = verify_area(VERIFY_WRITE, inf, sizeof(*inf));
			int i;
			int frags = 0, bytes = 0;

			if (!(file->f_mode & FMODE_READ))
                                return -EINVAL;

			if (err)
				return err;
			for(i = 0; i < s->nbfrags; i++){
			if (atomic_read(&s->buffers[i].sem.count) > 0)
                                {
                                        if (s->buffers[i].size == s->fragsize)
                                                frags++;
                                        bytes += s->buffers[i].size;
                                }
                        }
			put_user(frags, &inf->fragments);
                        put_user(s->nbfrags, &inf->fragstotal);
                        put_user(s->fragsize, &inf->fragsize);
                        put_user(bytes, &inf->bytes);
                        break;
		}
	  	case SNDCTL_DSP_RESET:
			if (file->f_mode & FMODE_READ) {
                                audio_clear_buf(&input_stream);
                        }
                        if (file->f_mode & FMODE_WRITE) {
                                audio_clear_buf(&output_stream);
                        }
                        return 0;
		case SNDCTL_DSP_NONBLOCK:
			file->f_flags |= O_NONBLOCK;
                        return 0;
	 	case SNDCTL_DSP_POST:
	      	case SNDCTL_DSP_SUBDIVIDE:
	      	case SNDCTL_DSP_GETCAPS:
	      	case SNDCTL_DSP_GETTRIGGER:
	      	case SNDCTL_DSP_SETTRIGGER:
	      	case SNDCTL_DSP_GETIPTR:
	      	case SNDCTL_DSP_GETOPTR:
	      	case SNDCTL_DSP_MAPINBUF:
	      	case SNDCTL_DSP_MAPOUTBUF:
	      	case SNDCTL_DSP_SETSYNCRO:
	      	case SNDCTL_DSP_SETDUPLEX:
		  	return -ENOSYS;
	  	default:
		  	return smdk2410_mixer_ioctl(inode, file, cmd, arg);
	}

	return 0;
}


/*打开设备文件的接口函数，这里先看针对DSP 设备文件的函数：
首先上来就是一大段条件判断，主要就是判断file->f_flags 这个
表示设备文件的打开方式是读取，写入，还是可读写。
用audio_rd_refcount 和audio_wr_refcount 这两个变量来设置类似于信号量
一样的读写占位标志（要写设备的话，只要没有用写方式
打开过设备即可；要读的话，则需要该设备同时没有用读
或写方式打开过），只要打开过设备文件，相应的方式标志
就会加一。  if (cold) {
  audio_rate = AUDIO_RATE_DEFAULT;
  audio_channels = AUDIO_CHANNELS_DEFAULT;
  audio_fragsize = AUDIO_FRAGSIZE_DEFAULT;
  audio_nbfrags = AUDIO_NBFRAGS_DEFAULT;     在audio_rd_refcount 和audio_wr_refcount 
  这两个变量都为0 的时候才进入这一步，即对已经打开过
  的设备文件不进行下面的操作。
    这里先设置一下待会儿要配置到IIS 相关寄存器中的变量。   
    if ((file->f_mode & FMODE_WRITE)){
    init_s3c2410_iis_bus_tx();
    audio_clear_buf(&output_stream);
  }
  if ((file->f_mode & FMODE_READ)){
    init_s3c2410_iis_bus_rx();
    audio_clear_buf(&input_stream);
  }