s3c2410-uda1341.c

s3c2410 uda1341 linux 2.6.14 driver

        }

        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;