Chinaunix首页 | 论坛 | 博客
  • 博客访问: 3467
  • 博文数量: 3
  • 博客积分: 168
  • 博客等级: 入伍新兵
  • 技术积分: 40
  • 用 户 组: 普通用户
  • 注册时间: 2010-05-20 10:42
文章分类
文章存档

2010年(3)

最近访客

分类: 嵌入式

2010-05-20 10:48:10

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include

#include
#include
#include
#include
#include
#include
#include
#include
//#include
#include
#include
#include
#include
#include
//#include
//add here
#include
#include
#define PFX "s3c2410-uda1341-superlp: "


/* The S3C2410 has four internal DMA channels. */
#ifndef __ASSEMBLY__
#define UData(Data)  ((unsigned long) (Data))
#else
#define UData(Data)  (Data)
#endif
#define MAX_S3C2410_DMA_CHANNELS S3C2410_DMA_CHANNELS
#define FShft(Field)  ((Field) & 0x0000FFFF)
#define DMA_CH0 0
#define DMA_CH1 1
#define DMA_CH2 2
#define DMA_CH3 3

#define Fld(Size, Shft)  (((Size) << 16) + (Shft))
#define FInsrt(Value, Field)    (UData (Value) << FShft (Field))
#define fIISPSR_A    Fld(5,5)
#define IISPSR_A(x)    FInsrt((x), fIISPSR_A)
#define fIISPSR_B    Fld(5,0)
#define IISPSR_B(x)    FInsrt((x), fIISPSR_B)


//以下在static int iispsr_value(int s_bit_clock, int sample_rate)等多处出现
static struct clk *iis_clock;
// 以下用于audio_set_dsp_speed()函数中
static void __iomem *iis_base;

//结构体struct s3c2410_dma_client用于audio_clear_dma()函数中,s3c2410iis_dma_out变量用于//audio_init_dma(),audio_init_dma 函

数来分别对输出和输入音频缓冲区的DMA通道进行初始化设置
static struct s3c2410_dma_client s3c2410iis_dma_out= {
.name = "I2SSDO",
};

// s3c2410iis_dma_in变量用于audio_init_dma()和s3c2410iis_probe()中
static struct s3c2410_dma_client s3c2410iis_dma_in = {
.name = "I2SSDI",
};



#ifdef DEBUG
#define DPRINTK printk
#else
#define DPRINTK( x... )
#endif

// 以下两者用于smdk2410_audio_open()函数,init_s3c2410_iis_bus_tx 和init_s3c2410_iis_bus_rx
//函数来进行对IIS总线读写的初始化配置,在这两个函数中对S3C2410 芯片的IIS 相关寄存器进行了相应的配置
static void init_s3c2410_iis_bus_rx(void);
static void init_s3c2410_iis_bus_tx(void);

#define DEF_VOLUME 65

/* UDA1341 Register bits */
// init_uda1341()中使用
#define UDA1341_ADDR 0x14

#define UDA1341_REG_DATA0 (UDA1341_ADDR + 0)
#define UDA1341_REG_STATUS (UDA1341_ADDR + 2)
/* status control */
#define STAT0 (0x00)
#define STAT0_RST (1 << 6)
#define STAT0_SC_MASK (3 << 4)
#define STAT0_SC_512FS (0 << 4)
#define STAT0_SC_384FS (1 << 4)
#define STAT0_SC_256FS (2 << 4)
#define STAT0_IF_MASK (7 << 1)
#define STAT0_IF_I2S (0 << 1)
#define STAT0_IF_LSB16 (1 << 1)
#define STAT0_IF_LSB18 (2 << 1)
#define STAT0_IF_LSB20 (3 << 1)
#define STAT0_IF_MSB (4 << 1)
#define STAT0_IF_LSB16MSB (5 << 1)
#define STAT0_IF_LSB18MSB (6 << 1)
#define STAT0_IF_LSB20MSB (7 << 1)
#define STAT0_DC_FILTER (1 << 0)
#define STAT0_DC_NO_FILTER (0 << 0)
#define S3C2410_IISMOD_MASTER (0 << 8)
#define STAT1 (0x80)
#define STAT1_DAC_GAIN (1 << 6) /* gain of DAC */
#define STAT1_ADC_GAIN (1 << 5) /* gain of ADC */
#define STAT1_ADC_POL (1 << 4) /* polarity of ADC */
#define STAT1_DAC_POL (1 << 3) /* polarity of DAC */
#define STAT1_DBL_SPD (1 << 2) /* double speed playback */
#define STAT1_ADC_ON (1 << 1) /* ADC powered */
#define STAT1_DAC_ON (1 << 0) /* DAC powered */

/* data0 direct control */
#define DATA0 (0x00)
#define DATA0_VOLUME_MASK (0x3f)
#define DATA0_VOLUME(x) (x)

#define DATA1 (0x40)
#define DATA1_BASS(x) ((x) << 2)
#define DATA1_BASS_MASK (15 << 2)
#define DATA1_TREBLE(x) ((x))
#define DATA1_TREBLE_MASK (3)

#define DATA2 (0x80)
#define DATA2_PEAKAFTER (0x1 << 5)
#define DATA2_DEEMP_NONE (0x0 << 3)
#define DATA2_DEEMP_32KHz (0x1 << 3)
#define DATA2_DEEMP_44KHz (0x2 << 3)
#define DATA2_DEEMP_48KHz (0x3 << 3)
#define DATA2_MUTE (0x1 << 2)
#define DATA2_FILTER_FLAT (0x0 << 0)
#define DATA2_FILTER_MIN (0x1 << 0)
#define DATA2_FILTER_MAX (0x3 << 0)
/* data0 extend control */
#define EXTADDR(n) (0xc0 | (n))
#define EXTDATA(d) (0xe0 | (d))

#define EXT0 0
#define EXT0_CH1_GAIN(x) (x)
#define EXT1 1
#define EXT1_CH2_GAIN(x) (x)
#define EXT2 2
#define EXT2_MIC_GAIN_MASK (7 << 2)
#define EXT2_MIC_GAIN(x) ((x) << 2)
#define EXT2_MIXMODE_DOUBLEDIFF (0)
#define EXT2_MIXMODE_CH1 (1)
#define EXT2_MIXMODE_CH2 (2)
#define EXT2_MIXMODE_MIX (3)
#define EXT4 4
#define EXT4_AGC_ENABLE (1 << 4)
#define EXT4_INPUT_GAIN_MASK (3)
#define EXT4_INPUT_GAIN(x) ((x) & 3)
#define EXT5 5
#define EXT5_INPUT_GAIN(x) ((x) >> 2)
#define EXT6 6
#define EXT6_AGC_CONSTANT_MASK (7 << 2)
#define EXT6_AGC_CONSTANT(x) ((x) << 2)
#define EXT6_AGC_LEVEL_MASK (3)
#define EXT6_AGC_LEVEL(x) (x)

#define AUDIO_NAME "UDA1341"
#define AUDIO_NAME_VERBOSE "UDA1341 audio driver"

#define AUDIO_FMT_MASK (AFMT_S16_LE)  
#define AUDIO_FMT_DEFAULT (AFMT_S16_LE)

#define AUDIO_CHANNELS_DEFAULT 2    //重要
#define AUDIO_RATE_DEFAULT 44100

#define AUDIO_NBFRAGS_DEFAULT 8
#define AUDIO_FRAGSIZE_DEFAULT 8192

#define S_CLOCK_FREQ 384    //CODECLK采样频率类型,256或384fs中之一  
#define PCM_ABS(a) (a < 0 ? -a : a)   //求相反数

typedef struct {
int size;       /* buffer size */
char *start;       /*内存虚拟地址起始地址*/
dma_addr_t dma_addr;  /*内存物理地址起始地址*/
struct semaphore sem;  /* down before touching the buffer */
int master;       /*内存大小*/
} audio_buf_t;

typedef struct {
audio_buf_t *buffers;  /* pointer to audio buffer structures */
audio_buf_t *buf;     /* current buffer used by read/write */
u_int buf_idx;     /* index for the pointer above */
u_int fragsize;     /*音频缓冲区片大小*/
u_int nbfrags;     /*音频缓冲区片数量*/
dmach_t dma_ch;     /* DMA channel (channel2 for audio) */
u_int dma_ok;       /*仅用于audio_clear_buf ()函数中 */
} audio_stream_t;

static audio_stream_t output_stream;
static audio_stream_t input_stream; /* input */

#define NEXT_BUF(_s_,_b_) { \
(_s_)->_b_##_idx++; \
(_s_)->_b_##_idx %= (_s_)->nbfrags; \
(_s_)->_b_ = (_s_)->buffers + (_s_)->_b_##_idx; }

//以下的变量后文均多次用到  
static u_int audio_rate;  //音频采样频率
static int audio_channels;
static int audio_fmt;  
static u_int audio_fragsize;
static u_int audio_nbfrags;


static int audio_rd_refcount;
static int audio_wr_refcount;
#define audio_active (audio_rd_refcount | audio_wr_refcount)

static int audio_dev_dsp;
static int audio_dev_mixer;
static int audio_mix_modcnt;

static int uda1341_volume;
//static u8 uda_sampling;
static int uda1341_boost;
static int mixer_igain=0x4; /* -6db*/

//使用于smdk2410_mixer_ioctl()和init_uda1341()函数中  
static void uda1341_l3_address(u8 data)
{
int i;
unsigned long flags;

local_irq_save(flags);

// write_gpio_bit(GPIO_L3MODE, 0);
s3c2410_gpio_setpin(S3C2410_GPB2,0);
// write_gpio_bit(GPIO_L3CLOCK, 1);
s3c2410_gpio_setpin(S3C2410_GPB4,1);
udelay(1);

for (i = 0; i < 8; i++) {
if (data & 0x1) {
s3c2410_gpio_setpin(S3C2410_GPB4,0);
s3c2410_gpio_setpin(S3C2410_GPB3,1);
udelay(1);
s3c2410_gpio_setpin(S3C2410_GPB4,1);
} else {
s3c2410_gpio_setpin(S3C2410_GPB4,0);
s3c2410_gpio_setpin(S3C2410_GPB3,0);
udelay(1);
s3c2410_gpio_setpin(S3C2410_GPB4,1);
}
data >>= 1;
}

s3c2410_gpio_setpin(S3C2410_GPB2,1);
s3c2410_gpio_setpin(S3C2410_GPB4,1);
local_irq_restore(flags);
}

static void uda1341_l3_data(u8 data)
{
int i;
unsigned long flags;

local_irq_save(flags);
udelay(1);

for (i = 0; i < 8; i++) {
if (data & 0x1) {
s3c2410_gpio_setpin(S3C2410_GPB4,0);
s3c2410_gpio_setpin(S3C2410_GPB3,1);
udelay(1);
s3c2410_gpio_setpin(S3C2410_GPB4,1);
} else {
s3c2410_gpio_setpin(S3C2410_GPB4,0);
s3c2410_gpio_setpin(S3C2410_GPB3,0);
udelay(1);
s3c2410_gpio_setpin(S3C2410_GPB4,1);
}

data >>= 1;
}

local_irq_restore(flags);
}

static void audio_clear_buf(audio_stream_t * s)
{
DPRINTK("audio_clear_buf\n");

if(s->dma_ok) s3c2410_dma_ctrl(s->dma_ch, S3C2410_DMAOP_FLUSH);

if (s->buffers) {
int frag;

for (frag = 0; frag < s->nbfrags; frag++) {
if (!s->buffers[frag].master)
continue;
dma_free_coherent(NULL,
s->buffers[frag].master,
s->buffers[frag].start,
s->buffers[frag].dma_addr);
}
kfree(s->buffers);
s->buffers = NULL;
}

s->buf_idx = 0;
s->buf = NULL;
}

static int audio_setup_buf(audio_stream_t * s)
{
int frag;
int dmasize = 0;
char *dmabuf = 0;
dma_addr_t dmaphys = 0;

if (s->buffers)return -EBUSY;

s->nbfrags = audio_nbfrags;
s->fragsize = audio_fragsize;

s->buffers = (audio_buf_t *)
kmalloc(sizeof(audio_buf_t) * s->nbfrags, GFP_KERNEL);
if (!s->buffers)goto err;
memset(s->buffers, 0, sizeof(audio_buf_t) * s->nbfrags);

for (frag = 0; frag < s->nbfrags; frag++) {
audio_buf_t *b = &s->buffers[frag];

if (!dmasize) {
dmasize = (s->nbfrags - frag) * s->fragsize;
do {
dmabuf = dma_alloc_coherent(NULL, dmasize, &dmaphys, GFP_KERNEL|GFP_DMA);
if (!dmabuf)dmasize -= s->fragsize;
} while (!dmabuf && dmasize);
if (!dmabuf)goto err;
b->master = dmasize;
}

b->start = dmabuf;
b->dma_addr = dmaphys;
sema_init(&b->sem, 1);
DPRINTK("buf %d: start %p dma %d\n", frag, b->start, b->dma_addr);

dmabuf += s->fragsize;
dmaphys += s->fragsize;
dmasize -= s->fragsize;
}

s->buf_idx = 0;
s->buf = &s->buffers[0];
return 0;

err:
printk(AUDIO_NAME ": unable to allocate audio memory\n ");
audio_clear_buf(s);
return -ENOMEM;
}
static void audio_dmaout_done_callback(struct s3c2410_dma_chan *ch, void *buf, int size,enum s3c2410_dma_buffresult result)
{
audio_buf_t *b = (audio_buf_t *) buf;
up(&b->sem);
wake_up(&b->sem.wait);
}

static void audio_dmain_done_callback(struct s3c2410_dma_chan *ch, void *buf, int size,enum s3c2410_dma_buffresult result)
{
audio_buf_t *b = (audio_buf_t *) buf;
b->size = size;
up(&b->sem);
wake_up(&b->sem.wait);
}
/* using when write */
static int audio_sync(struct file *file)
{
audio_stream_t *s = &output_stream;
audio_buf_t *b = s->buf;

DPRINTK("audio_sync\n");

if (!s->buffers)return 0;

if (b->size != 0) {
down(&b->sem);
s3c2410_dma_enqueue(s->dma_ch, (void *) b, b->dma_addr, b->size);
b->size = 0;
NEXT_BUF(s, buf);
}

b = s->buffers + ((s->nbfrags + s->buf_idx - 1) % s->nbfrags);
if (down_interruptible(&b->sem))return -EINTR;
up(&b->sem);

return 0;
}

static inline int copy_from_user_mono_stereo(char *to, const char *from, int count)
{
u_int *dst = (u_int *)to;
const char *end = from + count;

if (access_ok(VERIFY_READ, from, count))return -EFAULT;

if ((int)from & 0x2) {
u_int v;
__get_user(v, (const u_short *)from); from += 2;
*dst++ = v | (v << 16);
}

while (from < end-2) {
u_int v, x, y;
__get_user(v, (const u_int *)from); from += 4;
x = v << 16;
x |= x >> 16;
y = v >> 16;
y |= y << 16;
*dst++ = x;
*dst++ = y;
}

if (from < end) {
u_int v;
__get_user(v, (const u_short *)from);
*dst = v | (v << 16);
}

return 0;
}


static ssize_t smdk2410_audio_write(struct file *file, const char *buffer,size_t count, loff_t * ppos)
{
  const char *buffer0 = buffer;
  audio_stream_t *s = &output_stream;
  int chunksize, ret = 0;

  DPRINTK("audio_write : start count=%d\n", count);

  switch (file->f_flags & O_ACCMODE) {
    case O_WRONLY:
    case O_RDWR:
    break;
    default:
      return -EPERM;
  }

  if (!s->buffers && audio_setup_buf(s))
    return -ENOMEM;

  count &= ~0x03;

  while (count > 0) {
    audio_buf_t *b = s->buf;

    if (file->f_flags & O_NONBLOCK) {
      ret = -EAGAIN;
      if (down_trylock(&b->sem))
        break;
    } else {
      ret = -ERESTARTSYS;
      if (down_interruptible(&b->sem))
      break;
    }

    if (audio_channels == 2) {
      chunksize = s->fragsize - b->size;
      if (chunksize > count)
      chunksize = count;
      DPRINTK("write %d to %d\n", chunksize, s->buf_idx);
      if (copy_from_user(b->start + b->size, buffer, chunksize)) {
        up(&b->sem);
        return -EFAULT;
      }
      b->size += chunksize;
    } else {
      chunksize = (s->fragsize - b->size) >> 1;

      if (chunksize > count)
      chunksize = count;
      DPRINTK("write %d to %d\n", chunksize*2, s->buf_idx);
      if (copy_from_user_mono_stereo(b->start + b->size,buffer, chunksize)) {
        up(&b->sem);
        return -EFAULT;
      }

      b->size += chunksize*2;
    }

    buffer += chunksize;
    count -= chunksize;
    if (b->size < s->fragsize) {
    up(&b->sem);
    break;
    }

    if((ret = s3c2410_dma_enqueue(s->dma_ch, (void *) b, b->dma_addr, b->size))) {
      printk(PFX"dma enqueue failed.\n");
      return ret;
    }
    b->size = 0;
    NEXT_BUF(s, buf);
  }

  if ((buffer - buffer0))
  ret = buffer - buffer0;

  DPRINTK("audio_write : end count=%d\n\n", ret);

  return ret;
}


static ssize_t smdk2410_audio_read(struct file *file, char *buffer,size_t count, loff_t * ppos)
{
  const char *buffer0 = buffer;
  audio_stream_t *s = &input_stream;
  int chunksize, ret = 0;

  DPRINTK("audio_read: count=%d\n", count);
/*
  if (ppos != &file->f_pos)
  return -ESPIPE;
*/
  if (!s->buffers) {
    int i;

    if (audio_setup_buf(s))
      return -ENOMEM;

    for (i = 0; i < s->nbfrags; i++) {
      audio_buf_t *b = s->buf;
      down(&b->sem);
      s3c2410_dma_enqueue(s->dma_ch, (void *) b, b->dma_addr, s->fragsize);
      NEXT_BUF(s, buf);
    }
  }

  while (count > 0) {
    audio_buf_t *b = s->buf;

/* Wait for a buffer to become full */
    if (file->f_flags & O_NONBLOCK) {
      ret = -EAGAIN;
      if (down_trylock(&b->sem))
        break;
    } else {
        ret = -ERESTARTSYS;
        if (down_interruptible(&b->sem))
        break;
    }

    chunksize = b->size;
    if (chunksize > count)
      chunksize = count;
    DPRINTK("read %d from %d\n", chunksize, s->buf_idx);
    if (copy_to_user(buffer, b->start + s->fragsize - b->size,chunksize)) {
      up(&b->sem);
      return -EFAULT;
    }

    b->size -= chunksize;

    buffer += chunksize;
    count -= chunksize;
    if (b->size > 0) {
      up(&b->sem);
      break;
    }

/* Make current buffer available for DMA again */
    s3c2410_dma_enqueue(s->dma_ch, (void *) b, b->dma_addr, s->fragsize);

    NEXT_BUF(s, buf);
  }

  if ((buffer - buffer0))
  ret = buffer - buffer0;

  // DPRINTK("audio_read: return=%d\n", ret);

  return ret;
}


static unsigned int smdk2410_audio_poll(struct file *file,struct poll_table_struct *wait)
{
unsigned int mask = 0;
int i;

DPRINTK("audio_poll(): mode=%s\n",
(file->f_mode & FMODE_WRITE) ? "w" : "");

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

for (i = 0; i < input_stream.nbfrags; i++) {
if (atomic_read(&input_stream.buffers[i].sem.count) > 0)
mask |= POLLIN | POLLWRNORM;
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);
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 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 = clk_get_rate(iis_clock) / 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)
{
unsigned int prescaler;
prescaler=(IISPSR_A(iispsr_value(S_CLOCK_FREQ, val))
| IISPSR_B(iispsr_value(S_CLOCK_FREQ, val)));
writel(prescaler, iis_base + S3C2410_IISPSR);

printk(PFX "audio_set_dsp_speed:%ld prescaler:%i\n",val,prescaler);
return (audio_rate = val);
}

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 audio_sync(file);

case SNDCTL_DSP_GETOSPACE:
{
audio_stream_t *s = &output_stream;
audio_buf_info *inf = (audio_buf_info *) arg;
int err = access_ok(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 = access_ok(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;
}


static int smdk2410_audio_open(struct inode *inode, struct file *file)
{
int cold = !audio_active;

DPRINTK("audio_open\n");
if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
if (audio_rd_refcount || audio_wr_refcount)
return -EBUSY;
audio_rd_refcount++;
} else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
if (audio_wr_refcount)
return -EBUSY;
audio_wr_refcount++;
} else if ((file->f_flags & O_ACCMODE) == O_RDWR) {
if (audio_rd_refcount || audio_wr_refcount)
return -EBUSY;
audio_rd_refcount++;
audio_wr_refcount++;
} else
return -EINVAL;

if (cold) {
audio_rate = AUDIO_RATE_DEFAULT;
audio_channels = AUDIO_CHANNELS_DEFAULT;
audio_fragsize = AUDIO_FRAGSIZE_DEFAULT;
audio_nbfrags = AUDIO_NBFRAGS_DEFAULT;
  if ((file->f_mode & FMODE_WRITE)){
    init_s3c2410_iis_bus_tx();
    audio_clear_buf(&output_stream);   
//新增
    if (!output_stream.buffers && audio_setup_buf(&output_stream))  
      return -ENOMEM;    }
if ((file->f_mode & FMODE_READ)){
init_s3c2410_iis_bus_rx();
audio_clear_buf(&input_stream);
}
}
return 0;
}


static int smdk2410_mixer_open(struct inode *inode, struct file *file)
{
return 0;
}


static int smdk2410_audio_release(struct inode *inode, struct file *file)
{
DPRINTK("audio_release\n");

if (file->f_mode & FMODE_READ) {
if (audio_rd_refcount == 1)
audio_clear_buf(&input_stream);
audio_rd_refcount = 0;
}

if(file->f_mode & FMODE_WRITE) {
if (audio_wr_refcount == 1) {
audio_sync(file);
audio_clear_buf(&output_stream);
audio_wr_refcount = 0;
}
}

return 0;
}


static int smdk2410_mixer_release(struct inode *inode, struct file *file)
{
return 0;
}


static struct file_operations smdk2410_audio_fops = {
llseek: smdk2410_audio_llseek,
write: smdk2410_audio_write,
read: smdk2410_audio_read,
poll: smdk2410_audio_poll,
ioctl: smdk2410_audio_ioctl,
open: smdk2410_audio_open,
release: smdk2410_audio_release
};

static struct file_operations smdk2410_mixer_fops = {
ioctl: smdk2410_mixer_ioctl,
open: smdk2410_mixer_open,
release: smdk2410_mixer_release
};

static void init_uda1341(void)
{

    /* GPB 4: L3CLOCK */
    /* GPB 3: L3DATA */
    /* GPB 2: L3MODE */

    unsigned long flags;

    uda1341_volume = 62 - ((DEF_VOLUME * 61) / 100);
    uda1341_boost = 0;
//    uda_sampling = DATA2_DEEMP_NONE;
//    uda_sampling &= ~(DATA2_MUTE);


    local_irq_save(flags);

    s3c2410_gpio_setpin(S3C2410_GPB2,1);//L3MODE=1
    s3c2410_gpio_setpin(S3C2410_GPB4,1);//L3CLOCK=1
    local_irq_restore(flags);

    uda1341_l3_address(UDA1341_REG_STATUS);
    uda1341_l3_data(0x40 | STAT0_SC_384FS | STAT0_IF_MSB|STAT0_DC_FILTER); // reset uda1341
    uda1341_l3_data(STAT1 | STAT1_ADC_ON | STAT1_DAC_ON);

    uda1341_l3_address(UDA1341_REG_DATA0);
    uda1341_l3_data(DATA0 |DATA0_VOLUME(0x0)); // maximum volume
    uda1341_l3_data(DATA1 |DATA1_BASS(uda1341_boost)| DATA1_TREBLE(0));
    uda1341_l3_data((DATA2 |DATA2_DEEMP_NONE) &~(DATA2_MUTE));
    uda1341_l3_data(EXTADDR(EXT2));
    uda1341_l3_data(EXTDATA(EXT2_MIC_GAIN(0x6)) | EXT2_MIXMODE_CH1);//input channel 1 select(input channel 2 off)

}

static void init_s3c2410_iis_bus(void)
{
    writel(0, iis_base + S3C2410_IISPSR);
    writel(0, iis_base + S3C2410_IISCON);
    writel(0, iis_base + S3C2410_IISMOD);
    writel(0, iis_base + S3C2410_IISFCON);
    clk_disable(iis_clock);
}
static void init_s3c2410_iis_bus_rx(void){
unsigned int iiscon, iismod, iisfcon;
char *dstr;  //读写标志
//将相关寄存器全部清空,其实就是上面的init_s3c2410_iis_bus()函数,可以直接调用
writel(0, iis_base + S3C2410_IISPSR);
writel(0, iis_base + S3C2410_IISCON);
writel(0, iis_base + S3C2410_IISMOD);
writel(0, iis_base + S3C2410_IISFCON);

clk_enable(iis_clock);

iiscon = iismod = iisfcon = 0;

//Setup basic stuff
iiscon |= S3C2410_IISCON_PSCEN; // Enable prescaler
iiscon |= S3C2410_IISCON_IISEN; // Enable interface

iismod |= S3C2410_IISMOD_MASTER; // Set interface to Master Mode
iismod |= S3C2410_IISMOD_LR_LLOW; // Low for left channel
iismod |= S3C2410_IISMOD_MSB; // IIS format
iismod |= S3C2410_IISMOD_16BIT; // Serial data bit/channel is 16 bit
iismod |= S3C2410_IISMOD_384FS; // Master clock freq = 384 fs
iismod |= S3C2410_IISMOD_32FS; // 32 fs

iisfcon|= S3C2410_IISFCON_RXDMA; //Set RX FIFO acces mode to DMA
iisfcon|= S3C2410_IISFCON_TXDMA; //Set RX FIFO acces mode to DMA

iiscon |= S3C2410_IISCON_RXDMAEN; //Enable RX DMA service request
iiscon |= S3C2410_IISCON_TXIDLE; //Set TX channel idle
iismod |= S3C2410_IISMOD_RXMODE; //Set RX Mode
iisfcon|= S3C2410_IISFCON_RXENABLE; //Enable RX Fifo
dstr="RX";
//setup the prescaler
audio_set_dsp_speed(audio_rate); //在这里完成了对S3C2410_IISPSR寄存器的操作

//iiscon has to be set last - it enables the interface
writel(iismod, iis_base + S3C2410_IISMOD);
writel(iisfcon, iis_base + S3C2410_IISFCON);
writel(iiscon, iis_base + S3C2410_IISCON);
}

static void init_s3c2410_iis_bus_tx(void)
{
unsigned int iiscon, iismod, iisfcon;
char *dstr;

//Kill everything...
writel(0, iis_base + S3C2410_IISPSR);  // S3C2410_IISPSR 0x55000008
writel(0, iis_base + S3C2410_IISCON); // S3C2410_IISCON 0x55000000
writel(0, iis_base + S3C2410_IISMOD); // S3C2410_IISMOD 0x55000004
writel(0, iis_base + S3C2410_IISFCON); // S3C2410_IISFCON 0x5500000c

clk_enable(iis_clock);


iiscon = iismod = iisfcon = 0;

//Setup basic stuff
iiscon |= S3C2410_IISCON_PSCEN; // Enable prescaler
iiscon |= S3C2410_IISCON_IISEN; // Enable interface

iismod |= S3C2410_IISMOD_MASTER; // Set interface to Master Mode
iismod |= S3C2410_IISMOD_LR_LLOW; // Low for left channel
iismod |= S3C2410_IISMOD_MSB; // MSB format
iismod |= S3C2410_IISMOD_16BIT; // Serial data bit/channel is 16 bit
iismod |= S3C2410_IISMOD_384FS; // Master clock freq = 384 fs
iismod |= S3C2410_IISMOD_32FS; // 32 fs

iisfcon|= S3C2410_IISFCON_RXDMA; //Set RX FIFO acces mode to DMA
iisfcon|= S3C2410_IISFCON_TXDMA; //Set TX FIFO acces mode to DMA

iiscon |= S3C2410_IISCON_TXDMAEN; //Enable TX DMA service request
iiscon |= S3C2410_IISCON_RXIDLE; //Set RX channel idle
iismod |= S3C2410_IISMOD_TXMODE; //Set TX Mode
iisfcon|= S3C2410_IISFCON_TXENABLE; //Enable TX Fifo
dstr="TX";

//setup the prescaler
audio_set_dsp_speed(audio_rate);


//iiscon has to be set last - it enables the interface
writel(iismod, iis_base + S3C2410_IISMOD);
writel(iisfcon, iis_base + S3C2410_IISFCON);
writel(iiscon, iis_base + S3C2410_IISCON);
}

static int __init audio_init_dma(audio_stream_t * s, char *desc)
{
    int ret ;
    enum s3c2410_dmasrc source;
    int hwcfg;
    unsigned long devaddr;
    dmach_t channel;
    int dcon;
    unsigned int flags = 0;

    if(s->dma_ch == DMA_CH2){
        channel = 2;
        source = S3C2410_DMASRC_MEM;
        hwcfg = 3;
        devaddr = 0x55000010;
        dcon = 0xa0800000;
        flags = S3C2410_DMAF_AUTOSTART;

        s3c2410_dma_devconfig(channel, source, hwcfg, devaddr);
        s3c2410_dma_config(channel, 2, dcon);
        s3c2410_dma_set_buffdone_fn(channel, audio_dmaout_done_callback);
        s3c2410_dma_setflags(channel, flags);
        ret = s3c2410_dma_request(s->dma_ch, &s3c2410iis_dma_out, NULL);
        s->dma_ok = 1;
        return ret;
    }
    else if(s->dma_ch == DMA_CH1){
        channel =1;
        source =S3C2410_DMASRC_HW;
        hwcfg =3;
        devaddr = 0x55000010;
        dcon = 0xa2900000;
        flags = S3C2410_DMAF_AUTOSTART;

        s3c2410_dma_devconfig(channel, source, hwcfg, devaddr);
        s3c2410_dma_config(channel, 2, dcon);
        s3c2410_dma_set_buffdone_fn(channel, audio_dmain_done_callback);
        s3c2410_dma_setflags(channel, flags);
        ret = s3c2410_dma_request(s->dma_ch, &s3c2410iis_dma_in, NULL);
        s->dma_ok =1;
        return ret ;
    }
else
return 1;
}

static int audio_clear_dma(audio_stream_t * s,struct s3c2410_dma_client *client)
{
    s3c2410_dma_set_buffdone_fn(s->dma_ch, NULL);
    s3c2410_dma_free(s->dma_ch, client);
return 0;
}

static int s3c2410iis_probe(struct device *dev)
{
    struct platform_device *pdev = to_platform_device(dev);  
    struct resource *res;
    unsigned long flags;
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
    if (res == NULL) {
        printk(KERN_INFO PFX "failed to get memory region resouce\n");
        return -ENOENT;
    }

    iis_base = (void *)S3C24XX_VA_IIS ;  
    if (iis_base == 0) {
        printk(KERN_INFO PFX "failed to ioremap() region\n");
        return -EINVAL;
    }
//enable iis clock by lk
    iis_clock = clk_get(dev, "iis");
    if (iis_clock == NULL) {
        printk(KERN_INFO PFX "failed to find clock source\n");
        return -ENOENT;
    }
/**modify here**/   
clk_enable(iis_clock);//这个很重要,因为2.6.16以后,函数名就变了,所以要让他改过来。
/***end add***/
    local_irq_save(flags);  //保存IRQ 中断使能状态,并禁止IRQ 中断
//将GPB4,GPB3,GPB2 这3个GPIO 引脚设置为输出模式
/* GPB 4: L3CLOCK, OUTPUT */
    s3c2410_gpio_cfgpin(S3C2410_GPB4, S3C2410_GPB4_OUTP);
    s3c2410_gpio_pullup(S3C2410_GPB4,1);
/* GPB 3: L3DATA, OUTPUT */
    s3c2410_gpio_cfgpin(S3C2410_GPB3,S3C2410_GPB3_OUTP);
/* GPB 2: L3MODE, OUTPUT */
    s3c2410_gpio_cfgpin(S3C2410_GPB2,S3C2410_GPB2_OUTP);
    s3c2410_gpio_pullup(S3C2410_GPB2,1);
//将GPE0~GPE4 这5个引脚设置为IIS 接口的信号模式,可参考原理图
/* GPE 3: I2SSDI */
    s3c2410_gpio_cfgpin(S3C2410_GPE3,S3C2410_GPE3_I2SSDI);
    s3c2410_gpio_pullup(S3C2410_GPE3,1);
/* GPE 0: I2SLRCK */
    s3c2410_gpio_cfgpin(S3C2410_GPE0,S3C2410_GPE0_I2SLRCK);
    s3c2410_gpio_pullup(S3C2410_GPE0,1);
/* GPE 1: I2SSCLK */
    s3c2410_gpio_cfgpin(S3C2410_GPE1,S3C2410_GPE1_I2SSCLK);
    s3c2410_gpio_pullup(S3C2410_GPE1,1);
/* GPE 2: CDCLK */
    s3c2410_gpio_cfgpin(S3C2410_GPE2,S3C2410_GPE2_CDCLK);
    s3c2410_gpio_pullup(S3C2410_GPE2,1);
/* GPE 4: I2SSDO */
    s3c2410_gpio_cfgpin(S3C2410_GPE4,S3C2410_GPE4_I2SSDO);
    s3c2410_gpio_pullup(S3C2410_GPE4,1);

    local_irq_restore(flags);  //中断恢复   

    init_s3c2410_iis_bus();    //初始化iis总线  

    init_uda1341();    //初始化uda1341芯片  

    output_stream.dma_ch = DMA_CH2;

    if (audio_init_dma(&output_stream, "UDA1341 out")) {
        audio_clear_dma(&output_stream,&s3c2410iis_dma_out);
        printk( KERN_WARNING AUDIO_NAME_VERBOSE
        ": unable to get DMA channels\n" );
        return -EBUSY;
    }

    input_stream.dma_ch = DMA_CH1;

    if (audio_init_dma(&input_stream, "UDA1341 in")) {
        audio_clear_dma(&input_stream,&s3c2410iis_dma_in);
        printk( KERN_WARNING AUDIO_NAME_VERBOSE
        ": unable to get DMA channels\n" );
        return -EBUSY;
    }
//注册音频和混音器设备   
    audio_dev_dsp = register_sound_dsp(&smdk2410_audio_fops, -1);
    audio_dev_mixer = register_sound_mixer(&smdk2410_mixer_fops, -1);

    printk(AUDIO_NAME_VERBOSE " initialized\n");

    return 0;
}


static int s3c2410iis_remove(struct device *dev)
{
    unregister_sound_dsp(audio_dev_dsp);
    unregister_sound_mixer(audio_dev_mixer);
    audio_clear_dma(&output_stream,&s3c2410iis_dma_out);
    audio_clear_dma(&input_stream,&s3c2410iis_dma_in); /* input */
    printk(AUDIO_NAME_VERBOSE " unloaded\n");
    return 0;
}


static struct device_driver s3c2410iis_driver = {
    .name = "s3c2410-iis",
    .bus = &platform_bus_type,  
    .probe = s3c2410iis_probe,
    .remove = s3c2410iis_remove,
};

//完成设备的初始化
static int __init s3c2410_uda1341_init(void) {
    memzero(&input_stream, sizeof(audio_stream_t));
    memzero(&output_stream, sizeof(audio_stream_t));
    return driver_register(&s3c2410iis_driver);
}

static void __exit s3c2410_uda1341_exit(void) {
    driver_unregister(&s3c2410iis_driver);
}


module_init(s3c2410_uda1341_init);
module_exit(s3c2410_uda1341_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("superlp<[email]xinshengtaier@eyou.com[/email]>");
MODULE_DESCRIPTION("S3C2410 uda1341 sound driver");
阅读(280) | 评论(0) | 转发(0) |
0

上一篇:libmad音频解码库分析--libmad简介

下一篇:没有了

给主人留下些什么吧!~~