dmy.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

/* $Id: dmy.c,v 1.6 2000/12/13 05:06:26 davem Exp $
 * drivers/sbus/audio/dummy.c
 *
 * Copyright 1998 Derrick J Brashear ([e-mail])
 *
 * This is a dummy lowlevel driver. Consider it a distant cousin of 
 * /proc/audio; It pretends to be a piece of audio hardware, and writes
 * to a file instead. (or will shortly)
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/malloc.h>
#include <linux/init.h>
#include <linux/soundcard.h>
#include <linux/delay.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/sbus.h>

#include <asm/audioio.h>
#include "dummy.h"

#define MAX_DRIVERS 1
static struct sparcaudio_driver drivers[MAX_DRIVERS];
static int num_drivers;

static int dummy_play_gain(struct sparcaudio_driver *drv, int value, 
                            unsigned char balance);
static int dummy_record_gain(struct sparcaudio_driver *drv, int value, 
                            unsigned char balance);
static int dummy_output_muted(struct sparcaudio_driver *drv, int value);
static int dummy_attach(struct sparcaudio_driver *drv);

static int
dummy_set_output_encoding(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        if (value != 0) {
                dummy_chip->perchip_info.play.encoding = value;
                return 0;
        }
        return -EINVAL;
}

static int
dummy_set_input_encoding(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        if (value != 0) {
                dummy_chip->perchip_info.record.encoding = value;
                return 0;
        }
        return -EINVAL;
}

static int dummy_get_output_encoding(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.encoding;
}

static int dummy_get_input_encoding(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.encoding;
}

static int
dummy_set_output_rate(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        if (value != 0) {
                dummy_chip->perchip_info.play.sample_rate = value;
                return 0;
        }
        return -EINVAL;
}

static int
dummy_set_input_rate(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        if (value != 0) {
                dummy_chip->perchip_info.record.sample_rate = value;
                return 0;
        }
        return -EINVAL;
}

static int dummy_get_output_rate(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.sample_rate;
}

static int dummy_get_input_rate(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.sample_rate;
}

/* Generically we support 4 channels. This does 2 */
static int
dummy_set_output_channels(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        switch (value) {
        case 1:
        case 2:
                break;
        default:
                return -(EINVAL);
        };

        dummy_chip->perchip_info.play.channels = value;
        return 0;
}

/* Generically we support 4 channels. This does 2 */
static int
dummy_set_input_channels(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        switch (value) {
        case 1:
        case 2:
                break;
        default:
                return -(EINVAL);
        };

        dummy_chip->perchip_info.record.channels = value;
        return 0;
}

static int dummy_get_input_channels(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.channels;
}

static int dummy_get_output_channels(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.channels;
}

static int dummy_get_output_precision(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.precision;
}

static int dummy_get_input_precision(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.precision;
}

static int dummy_set_output_precision(struct sparcaudio_driver *drv, int val)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private; 

        dummy_chip->perchip_info.play.precision = val;
        return dummy_chip->perchip_info.play.precision;
}

static int dummy_set_input_precision(struct sparcaudio_driver *drv, int val)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private; 

        dummy_chip->perchip_info.record.precision = val;
        return dummy_chip->perchip_info.record.precision;
}

/* Set output mute */
static int dummy_output_muted(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        if (!value) 
                dummy_chip->perchip_info.output_muted = 0;
        else
                dummy_chip->perchip_info.output_muted = 1;

        return 0;
}

static int dummy_get_output_muted(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.output_muted;
}

static int dummy_get_formats(struct sparcaudio_driver *drv)
{
        return (AFMT_MU_LAW | AFMT_A_LAW |
                AFMT_U8 | AFMT_IMA_ADPCM | 
                AFMT_S16_LE | AFMT_S16_BE);
}

static int dummy_get_output_ports(struct sparcaudio_driver *drv)
{
        return (AUDIO_LINE_OUT | AUDIO_SPEAKER | AUDIO_HEADPHONE);
}

static int dummy_get_input_ports(struct sparcaudio_driver *drv)
{
        return (AUDIO_ANALOG_LOOPBACK);
}

/* Set chip "output" port */
static int dummy_set_output_port(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        dummy_chip->perchip_info.play.port = value;
        return value;
}

static int dummy_set_input_port(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        dummy_chip->perchip_info.record.port = value;
        return value;
}

static int dummy_get_output_port(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.port;
}

static int dummy_get_input_port(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.port;
}

static int dummy_get_output_error(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return (int) dummy_chip->perchip_info.play.error;
}

static int dummy_get_input_error(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return (int) dummy_chip->perchip_info.record.error;
}

static int dummy_get_output_samples(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.samples;
}

static int dummy_get_output_pause(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return (int) dummy_chip->perchip_info.play.pause;
}

static int dummy_set_output_volume(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        dummy_play_gain(drv, value, dummy_chip->perchip_info.play.balance);
        return 0;
}

static int dummy_get_output_volume(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.play.gain;
}

static int dummy_set_output_balance(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        dummy_chip->perchip_info.play.balance = value;
        dummy_play_gain(drv, dummy_chip->perchip_info.play.gain, 
                        dummy_chip->perchip_info.play.balance);
        return 0;
}

static int dummy_get_output_balance(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return (int) dummy_chip->perchip_info.play.balance;
}

/* Set chip play gain */
static int dummy_play_gain(struct sparcaudio_driver *drv,
                           int value, unsigned char balance)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;
        int tmp = 0, r, l, r_adj, l_adj;

        r = l = value;
        if (balance < AUDIO_MID_BALANCE) {
                r = (int) (value -
                           ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT));

                if (r < 0)
                        r = 0;
        } else if (balance > AUDIO_MID_BALANCE) {
                l = (int) (value -
                           ((balance - AUDIO_MID_BALANCE) << AUDIO_BALANCE_SHIFT));

                if (l < 0)
                        l = 0;
        }
        (l == 0) ? (l_adj = DUMMY_MAX_DEV_ATEN) : (l_adj = DUMMY_MAX_ATEN - 
                                                   (l * (DUMMY_MAX_ATEN + 1) / 
                                                    (AUDIO_MAX_GAIN + 1)));
        (r == 0) ? (r_adj = DUMMY_MAX_DEV_ATEN) : (r_adj = DUMMY_MAX_ATEN -
                                                   (r * (DUMMY_MAX_ATEN + 1) /
                                                    (AUDIO_MAX_GAIN + 1)));
        if ((value == 0) || (value == AUDIO_MAX_GAIN)) {
                tmp = value;
        } else {
                if (value == l) {
                        tmp = ((DUMMY_MAX_ATEN - l_adj) * (AUDIO_MAX_GAIN + 1) / 
                               (DUMMY_MAX_ATEN + 1));
                } else if (value == r) {
                        tmp = ((DUMMY_MAX_ATEN - r_adj) * (AUDIO_MAX_GAIN + 1) / 
                               (DUMMY_MAX_ATEN + 1));
                }
        }
        dummy_chip->perchip_info.play.gain = tmp;
        return 0;
}

static int dummy_get_input_samples(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.samples;
}

static int dummy_get_input_pause(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return (int) dummy_chip->perchip_info.record.pause;
}

static int dummy_set_monitor_volume(struct sparcaudio_driver *drv, int value)
{
        return 0;
}

static int dummy_get_monitor_volume(struct sparcaudio_driver *drv)
{
        return 0;
}

static int dummy_set_input_volume(struct sparcaudio_driver *drv, int value)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        dummy_record_gain(drv, value, dummy_chip->perchip_info.record.balance);
        return 0;
}

static int dummy_get_input_volume(struct sparcaudio_driver *drv)
{
        struct dummy_chip *dummy_chip = (struct dummy_chip *) drv->private;

        return dummy_chip->perchip_info.record.gain;
}