/* Does not work. Warning may block system in capture mode */
/* #define USE_VAR48KRATE */
-/* Define this if you want soft ac3 encoding */
-#define DO_SOFT_AC3
-#define USE_AES_IEC958
-
#include <sound/driver.h>
#include <asm/io.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/gameport.h>
+#include <linux/moduleparam.h>
#include <sound/core.h>
#include <sound/info.h>
#include <sound/control.h>
#include <sound/opl3.h>
#include <sound/sb.h>
#include <sound/asoundef.h>
-#define SNDRV_GET_ID
#include <sound/initval.h>
MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("C-Media CMI8x38 PCI");
MODULE_LICENSE("GPL");
-MODULE_CLASSES("{sound}");
-MODULE_DEVICES("{{C-Media,CMI8738},"
+MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8738},"
"{C-Media,CMI8738B},"
"{C-Media,CMI8338A},"
"{C-Media,CMI8338B}}");
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable switches */
static long mpu_port[SNDRV_CARDS];
static long fm_port[SNDRV_CARDS];
-#ifdef DO_SOFT_AC3
static int soft_ac3[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)]=1};
-#endif
#ifdef SUPPORT_JOYSTICK
static int joystick_port[SNDRV_CARDS];
#endif
+static int boot_devs;
-MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+module_param_array(index, int, boot_devs, 0444);
MODULE_PARM_DESC(index, "Index value for C-Media PCI soundcard.");
-MODULE_PARM_SYNTAX(index, SNDRV_INDEX_DESC);
-MODULE_PARM(id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
+module_param_array(id, charp, boot_devs, 0444);
MODULE_PARM_DESC(id, "ID string for C-Media PCI soundcard.");
-MODULE_PARM_SYNTAX(id, SNDRV_ID_DESC);
-MODULE_PARM(enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+module_param_array(enable, bool, boot_devs, 0444);
MODULE_PARM_DESC(enable, "Enable C-Media PCI soundcard.");
-MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-MODULE_PARM(mpu_port, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
+module_param_array(mpu_port, long, boot_devs, 0444);
MODULE_PARM_DESC(mpu_port, "MPU-401 port.");
-MODULE_PARM_SYNTAX(mpu_port, SNDRV_ENABLED ",allows:{{0},{0x330},{0x320},{0x310},{0x300}},dialog:list");
-MODULE_PARM(fm_port, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
+module_param_array(fm_port, long, boot_devs, 0444);
MODULE_PARM_DESC(fm_port, "FM port.");
-MODULE_PARM_SYNTAX(fm_port, SNDRV_ENABLED ",allows:{{0},{0x388},{0x3c8},{0x3e0},{0x3e8}},dialog:list");
-#ifdef DO_SOFT_AC3
-MODULE_PARM(soft_ac3, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
+module_param_array(soft_ac3, bool, boot_devs, 0444);
MODULE_PARM_DESC(soft_ac3, "Sofware-conversion of raw SPDIF packets (model 033 only).");
-MODULE_PARM_SYNTAX(soft_ac3, SNDRV_ENABLED "," SNDRV_BOOLEAN_TRUE_DESC);
-#endif
#ifdef SUPPORT_JOYSTICK
-MODULE_PARM(joystick_port, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+module_param_array(joystick_port, int, boot_devs, 0444);
MODULE_PARM_DESC(joystick_port, "Joystick port address.");
-MODULE_PARM_SYNTAX(joystick_port, SNDRV_ENABLED ",allows:{{0},{1},{0x200},{0x201}},dialog:list");
#endif
#ifndef PCI_DEVICE_ID_CMEDIA_CM8738
typedef struct snd_stru_cmipci cmipci_t;
typedef struct snd_stru_cmipci_pcm cmipci_pcm_t;
-#define chip_t cmipci_t
-
struct snd_stru_cmipci_pcm {
snd_pcm_substream_t *substream;
int running; /* dac/adc running? */
unsigned int is_dac; /* is dac? */
int bytes_per_frame;
int shift;
- int ac3_shift; /* extra shift: 1 on soft ac3 mode */
};
/* mixer elements toggled/resumed during ac3 playback */
int irq;
unsigned long iobase;
- struct resource *res_iobase;
unsigned int ctrl; /* FUNCTRL0 current value */
snd_pcm_t *pcm; /* DAC/ADC PCM */
unsigned int dig_status;
unsigned int dig_pcm_status;
-#ifdef USE_AES_IEC958
- snd_ctl_elem_value_t *spdif_channel;
-#endif
- snd_kcontrol_t *spdif_pcm_ctl;
snd_pcm_hardware_t *hw_info[3]; /* for playbacks */
static int set_dac_channels(cmipci_t *cm, cmipci_pcm_t *rec, int channels)
{
- unsigned long flags;
-
if (channels > 2) {
if (! cm->can_multi_ch)
return -EINVAL;
if (rec->fmt != 0x03) /* stereo 16bit only */
return -EINVAL;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_set_bit(cm, CM_REG_LEGACY_CTRL, CM_NXCHG);
snd_cmipci_set_bit(cm, CM_REG_MISC_CTRL, CM_XCHGDAC);
if (channels > 4) {
snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_CHB3D6C);
snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_ENCENTER);
}
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
} else {
if (cm->can_multi_ch) {
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_NXCHG);
snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_CHB3D);
snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_CHB3D5C);
snd_cmipci_clear_bit(cm, CM_REG_LEGACY_CTRL, CM_CHB3D6C);
snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_ENCENTER);
snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_XCHGDAC);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
}
}
return 0;
static int snd_cmipci_pcm_prepare(cmipci_t *cm, cmipci_pcm_t *rec,
snd_pcm_substream_t *substream)
{
- unsigned long flags;
unsigned int reg, freq, val;
snd_pcm_runtime_t *runtime = substream->runtime;
/* buffer and period sizes in frame */
rec->dma_size = runtime->buffer_size << rec->shift;
rec->period_size = runtime->period_size << rec->shift;
- rec->dma_size <<= rec->ac3_shift;
- rec->period_size <<= rec->ac3_shift;
if (runtime->channels > 2) {
/* multi-channels */
rec->dma_size = (rec->dma_size * runtime->channels) / 2;
rec->period_size = (rec->period_size * runtime->channels) / 2;
}
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
/* set buffer address */
reg = rec->ch ? CM_REG_CH1_FRAME1 : CM_REG_CH0_FRAME1;
//snd_printd("cmipci: chformat = %08x\n", val);
rec->running = 0;
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return 0;
}
ptr = snd_cmipci_read(cm, reg) - rec->offset;
ptr = bytes_to_frames(substream->runtime, ptr);
#endif
- ptr >>= rec->ac3_shift;
if (substream->runtime->channels > 2)
ptr = (ptr * 2) / substream->runtime->channels;
return ptr;
return snd_cmipci_pcm_pointer(cm, &cm->channel[CM_CH_CAPT], substream);
}
-#ifdef DO_SOFT_AC3
-/*
- * special tricks for soft ac3 transfer:
- *
- * we compose an iec958 subframe from 16bit ac3 sample and
- * write the raw subframe via 32bit data mode.
- */
-
-# ifndef USE_AES_IEC958
-
-/* find parity for bit 4~30 */
-static unsigned int parity(unsigned int data)
-{
- unsigned int parity = 0;
- int counter = 4;
-
- data >>= 4; /* start from bit 4 */
- while (counter <= 30) {
- if (data & 1)
- parity++;
- data >>= 1;
- counter++;
- }
- return parity & 1;
-}
-
-/*
- * compose 32bit iec958 subframe with non-audio data.
- * bit 0-3 = preamble
- * 4-7 = aux (=0)
- * 8-27 = data (12-27 for 16bit)
- * 28 = validity (=0)
- * 29 = user data (=0)
- * 30 = channel status
- * 31 = parity
- *
- * channel status is assumed as consumer, non-audio
- * thus all 0 except bit 1
- */
-inline static u32 convert_ac3_32bit(cmipci_t *cm, u32 val)
-{
- u32 data = (u32)val << 12;
-
- if (cm->spdif_counter == 2 || cm->spdif_counter == 3) /* bit 1 */
- data |= 0x40000000; /* indicate AC-3 raw data */
- if (parity(data)) /* parity bit 4-30 */
- data |= 0x80000000;
- if (cm->spdif_counter == 0)
- data |= 3; /* preamble 'M' */
- else if (cm->spdif_counter & 1)
- data |= 5; /* odd, 'W' */
- else
- data |= 9; /* even, 'M' */
-
- cm->spdif_counter++;
- if (cm->spdif_counter == 384)
- cm->spdif_counter = 0;
-
- return data;
-}
-
-# else /* if USE_AES_IEC958 */
-
-/*
- * The bitstream handling
- */
-typedef struct iec958_stru_bitstream {
- u32 *data; /* Holds the current position */
- u32 left; /* Bits left in current 32bit frame */
- u32 word; /* The 32bit frame of the current position */
- u32 bits; /* All bits together */
- int err; /* Error condition */
-} iec958_bitstream_t ;
-
-static iec958_bitstream_t bs;
-
-/* Initialize ptr on the buffer */
-static void iec958_init_bitstream(u8 *buf, u32 size)
-{
- bs.data = (u32 *)buf; /* Set initial position */
- bs.word = *bs.data; /* The first 32bit frame */
- bs.left = 32; /* has exactly 32bits */
- bs.bits = size;
- bs.err = 0;
-}
-
-/* Remove ptr on the buffer */
-static void iec958_clear_bitstream(void)
-{
- bs.data = NULL;
- bs.left = 0;
- bs.err = 0;
-}
-
-/* Get bits from bitstream (max 32) */
-static inline u32 iec958_getbits(u32 bits)
-{
- u32 res;
-
- if (bs.bits < bits) {
- bits = bs.bits;
- bs.err = 1;
- }
- if (bits > 32) {
- bits = 32;
- bs.err = 1;
- }
- bs.bits -= bits;
-
-# ifdef WORDS_BIGENDIAN
- if (bits < bs.left) { /* Within 32bit frame */
- res = (bs.word << (32 - bs.left)) >> (32 - bits);
- bs.left -= bits;
- goto out;
- } /* We may cross the frame boundary */
- res = (bs.word << (32 - bs.left)) >> (32 - bs.left);
- bits -= bs.left;
-
- bs.word = *(++bs.data); /* Next 32bit frame */
-
- if (bits) /* Add remaining bits, if any */
- res = (res << bits) | (bs.word >> (32 - bits));
-
-# else /* not WORDS_BIGENDIAN */
-
- if (bits < bs.left) { /* Within 32bit frame */
- res = (bs.word << (32 - bits)) >> (32 - bits);
- bs.word >>= bits;
- bs.left -= bits;
- goto out;
- } /* We may cross the frame boundary */
- res = bs.word;
- bits -= bs.left;
-
- bs.word = *(++bs.data); /* Next 32bit frame */
-
- if (bits) { /* Add remaining bits, if any */
- res = res | (((bs.word << (32 - bits)) >> (32 - bits)) << bits);
- bs.word >>= bits;
- }
-# endif /* not WORDS_BIGENDIAN */
-
- bs.left = (32 - bits);
-out:
- return res;
-}
-
-static inline u32 iec958_bits_avail(void)
-{
- return bs.bits;
-}
-
-static inline int iec958_error(void)
-{
- return bs.err;
-}
-
-/*
- * Determine parity for time slots 4 upto 30
- * to be sure that bit 4 upt 31 will carry
- * an even number of ones and zeros.
- */
-static u32 iec958_parity(u32 data)
-{
- u32 parity = 0;
- int counter = 4;
-
- data >>= 4; /* start from bit 4 */
- while (counter++ <= 30) {
- if (data & 0x00000001)
- parity++;
- data >>= 1;
- }
- return (parity & 0x00000001);
-}
-
-/*
- * Compose 32bit iec958 subframe, two sub frames
- * build one frame with two channels.
- *
- * bit 0-3 = preamble
- * 4-7 = AUX (=0)
- * 8-27 = data (12-27 for 16bit, 8-27 for 20bit, and 24bit without AUX)
- * 28 = validity (0 for valid data, else 'in error')
- * 29 = user data (0)
- * 30 = channel status (24 bytes for 192 frames)
- * 31 = parity
- */
-
-static inline u32 iec958_subframe(cmipci_t *cm, snd_ctl_elem_value_t * ucontrol)
-{
- u32 data;
- u32 byte = cm->spdif_counter >> 4;
- u32 mask = 1 << ((cm->spdif_counter >> 1) - (byte << 3));
- u8 * status = ucontrol->value.iec958.status;
-
- if (status[2] & IEC958_AES2_PRO_SBITS_24) {
- /* Does this work for LE systems ??? */
- if (status[2] & IEC958_AES2_PRO_WORDLEN_24_20) {
- data = iec958_getbits(24);
- data <<= 4;
- } else {
- data = iec958_getbits(20);
- data <<= 8;
- }
- } else {
- if (status[2] & IEC958_AES2_PRO_WORDLEN_24_20) {
- /* Does this work for LE systems ??? */
- data = iec958_getbits(20);
- data <<= 8;
- } else {
- data = iec958_getbits(16);
- data <<= 12;
- }
- }
-
- /*
- * Set one of the 192 bits of the channel status (AES3 and higher)
- */
- if (status[byte] & mask)
- data |= 0x40000000;
-
- if (iec958_parity(data)) /* parity bit 4-30 */
- data |= 0x80000000;
-
- /* Preamble */
- if (!cm->spdif_counter)
- data |= 0x03; /* Block start, 'Z' */
- else if (cm->spdif_counter % 2)
- data |= 0x05; /* odd sub frame, 'Y' */
- else
- data |= 0x09; /* even sub frame, 'X' */
-
- /*
- * sub frame counter: 2 sub frame are one audio frame
- * and 192 frames are one block
- */
- cm->spdif_counter = (++cm->spdif_counter) % 384;
-
- return data;
-}
-# endif /* if USE_AES_IEC958 */
-
-static int snd_cmipci_ac3_copy(snd_pcm_substream_t *subs, int channel,
- snd_pcm_uframes_t pos, void *src,
- snd_pcm_uframes_t count)
-{
- cmipci_t *cm = snd_pcm_substream_chip(subs);
- u32 *dst;
- snd_pcm_uframes_t offset;
- snd_pcm_runtime_t *runtime = subs->runtime;
-#ifndef USE_AES_IEC958
- u16 *srcp = src, val;
-#else
- char buf[480]; /* bits can be divided by 20, 24, 16 */
- size_t bytes = frames_to_bytes(runtime, count);
-#endif
-
-
- if (!cm->channel[CM_CH_PLAY].ac3_shift) {
- if (copy_from_user(runtime->dma_area +
- frames_to_bytes(runtime, pos), src,
- frames_to_bytes(runtime, count)))
- return -EFAULT;
- return 0;
- }
-
- if (! access_ok(VERIFY_READ, src, count))
- return -EFAULT;
-
- /* frame = 16bit stereo */
- offset = (pos << 1) % (cm->channel[CM_CH_PLAY].dma_size << 2);
- dst = (u32*)(runtime->dma_area + offset);
-# ifndef USE_AES_IEC958
- count /= 2;
- while (count-- > 0) {
- get_user(val, srcp);
- srcp++;
- *dst++ = convert_ac3_32bit(cm, val);
- }
-# else
- while (bytes) {
- size_t c = bytes;
-
- if (c > sizeof(buf))
- c = sizeof(buf);
-
- if (copy_from_user(buf, src, c))
- return -EFAULT;
- bytes -= c;
- src += c;
-
- iec958_init_bitstream(buf, c*8);
- while (iec958_bits_avail()) {
- *(dst++) = iec958_subframe(cm, cm->spdif_channel);
- if (iec958_error())
- return -EINVAL;
- }
- iec958_clear_bitstream();
- }
-# endif
- return 0;
-}
-
-static int snd_cmipci_ac3_silence(snd_pcm_substream_t *subs, int channel,
- snd_pcm_uframes_t pos,
- snd_pcm_uframes_t count)
-{
- cmipci_t *cm = snd_pcm_substream_chip(subs);
- u32 *dst;
- snd_pcm_uframes_t offset;
- snd_pcm_runtime_t *runtime = subs->runtime;
-# ifdef USE_AES_IEC958
- char buf[480]; /* bits can be divided by 20, 24, 16 */
- size_t bytes = frames_to_bytes(runtime, count);
-# endif
- if (! cm->channel[CM_CH_PLAY].ac3_shift)
- return snd_pcm_format_set_silence(runtime->format,
- runtime->dma_area + frames_to_bytes(runtime, pos), count);
-
- /* frame = 16bit stereo */
- offset = (pos << 1) % (cm->channel[CM_CH_PLAY].dma_size << 2);
- dst = (u32*)(subs->runtime->dma_area + offset);
-# ifndef USE_AES_IEC958
- count /= 2;
- while (count-- > 0) {
- *dst++ = convert_ac3_32bit(cm, 0);
- }
-# else
- while (bytes) {
- size_t c = bytes;
-
- if (c > sizeof(buf))
- c = sizeof(buf);
-
- /* Q: Does this function know about 24bit silence? */
- if (snd_pcm_format_set_silence(runtime->format, buf, bytes_to_frames(runtime, c)))
- return -EINVAL;
-
- iec958_init_bitstream(buf, c*8);
- while (iec958_bits_avail()) {
- *(dst++) = iec958_subframe(cm, cm->spdif_channel);
- if (iec958_error())
- return -EINVAL;
- }
- iec958_clear_bitstream();
- }
-# endif
- return 0;
-}
-#endif /* DO_SOFT_AC3 */
-
/*
* hw preparation for spdif
snd_ctl_elem_value_t *ucontrol)
{
cmipci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
int i;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
for (i = 0; i < 4; i++)
ucontrol->value.iec958.status[i] = (chip->dig_status >> (i * 8)) & 0xff;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
snd_ctl_elem_value_t * ucontrol)
{
cmipci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
int i, change;
unsigned int val;
val = 0;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
for (i = 0; i < 4; i++)
val |= (unsigned int)ucontrol->value.iec958.status[i] << (i * 8);
change = val != chip->dig_status;
chip->dig_status = val;
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return change;
}
snd_ctl_elem_value_t *ucontrol)
{
cmipci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
int i;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
for (i = 0; i < 4; i++)
ucontrol->value.iec958.status[i] = (chip->dig_pcm_status >> (i * 8)) & 0xff;
-#ifdef USE_AES_IEC958
- ucontrol = chip->spdif_channel;
-#endif
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return 0;
}
snd_ctl_elem_value_t *ucontrol)
{
cmipci_t *chip = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
int i, change;
unsigned int val;
val = 0;
- spin_lock_irqsave(&chip->reg_lock, flags);
+ spin_lock_irq(&chip->reg_lock);
for (i = 0; i < 4; i++)
val |= (unsigned int)ucontrol->value.iec958.status[i] << (i * 8);
change = val != chip->dig_pcm_status;
chip->dig_pcm_status = val;
-#ifdef USE_AES_IEC958
- chip->spdif_channel = ucontrol;
-#endif
- spin_unlock_irqrestore(&chip->reg_lock, flags);
+ spin_unlock_irq(&chip->reg_lock);
return change;
}
*/
/* save mixer setting and mute for AC3 playback */
-static void save_mixer_state(cmipci_t *cm)
+static int save_mixer_state(cmipci_t *cm)
{
if (! cm->mixer_insensitive) {
+ snd_ctl_elem_value_t *val;
unsigned int i;
+
+ val = kmalloc(sizeof(*val), GFP_ATOMIC);
+ if (!val)
+ return -ENOMEM;
for (i = 0; i < CM_SAVED_MIXERS; i++) {
snd_kcontrol_t *ctl = cm->mixer_res_ctl[i];
if (ctl) {
- snd_ctl_elem_value_t val;
int event;
- memset(&val, 0, sizeof(val));
- ctl->get(ctl, &val);
- cm->mixer_res_status[i] = val.value.integer.value[0];
- val.value.integer.value[0] = cm_saved_mixer[i].toggle_on;
+ memset(val, 0, sizeof(*val));
+ ctl->get(ctl, val);
+ cm->mixer_res_status[i] = val->value.integer.value[0];
+ val->value.integer.value[0] = cm_saved_mixer[i].toggle_on;
event = SNDRV_CTL_EVENT_MASK_INFO;
- if (cm->mixer_res_status[i] != val.value.integer.value[0]) {
- ctl->put(ctl, &val); /* toggle */
+ if (cm->mixer_res_status[i] != val->value.integer.value[0]) {
+ ctl->put(ctl, val); /* toggle */
event |= SNDRV_CTL_EVENT_MASK_VALUE;
}
ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
snd_ctl_notify(cm->card, event, &ctl->id);
}
}
+ kfree(val);
cm->mixer_insensitive = 1;
}
+ return 0;
}
static void restore_mixer_state(cmipci_t *cm)
{
if (cm->mixer_insensitive) {
+ snd_ctl_elem_value_t *val;
unsigned int i;
+
+ val = kmalloc(sizeof(*val), GFP_KERNEL);
+ if (!val)
+ return;
cm->mixer_insensitive = 0; /* at first clear this;
otherwise the changes will be ignored */
for (i = 0; i < CM_SAVED_MIXERS; i++) {
snd_kcontrol_t *ctl = cm->mixer_res_ctl[i];
if (ctl) {
- snd_ctl_elem_value_t val;
int event;
- memset(&val, 0, sizeof(val));
+ memset(val, 0, sizeof(*val));
ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
- ctl->get(ctl, &val);
+ ctl->get(ctl, val);
event = SNDRV_CTL_EVENT_MASK_INFO;
- if (val.value.integer.value[0] != cm->mixer_res_status[i]) {
- val.value.integer.value[0] = cm->mixer_res_status[i];
- ctl->put(ctl, &val);
+ if (val->value.integer.value[0] != cm->mixer_res_status[i]) {
+ val->value.integer.value[0] = cm->mixer_res_status[i];
+ ctl->put(ctl, val);
event |= SNDRV_CTL_EVENT_MASK_VALUE;
}
snd_ctl_notify(cm->card, event, &ctl->id);
}
}
+ kfree(val);
}
}
/* spinlock held! */
static void setup_ac3(cmipci_t *cm, snd_pcm_substream_t *subs, int do_ac3, int rate)
{
- cm->channel[CM_CH_PLAY].ac3_shift = 0;
- cm->spdif_counter = 0;
-
if (do_ac3) {
/* AC3EN for 037 */
snd_cmipci_set_bit(cm, CM_REG_CHFORMAT, CM_AC3EN1);
snd_cmipci_set_bit(cm, CM_REG_CHFORMAT, CM_SPD24SEL);
snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_SPD32SEL);
} else { /* can_ac3_sw */
-#ifdef DO_SOFT_AC3
- /* FIXME: ugly hack! */
- subs->runtime->buffer_size /= 2;
/* SPD32SEL for 037 & 039, 0x20 */
snd_cmipci_set_bit(cm, CM_REG_MISC_CTRL, CM_SPD32SEL);
/* set 176K sample rate to fix 033 HW bug */
snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_PLAYBACK_SRATE_176K);
}
}
- cm->channel[CM_CH_PLAY].ac3_shift = 1; /* use 32bit */
-#endif /* DO_SOFT_AC3 */
}
} else {
snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_SPD24SEL);
}
} else {
-#ifdef DO_SOFT_AC3
snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_SPD32SEL);
snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_SPD24SEL);
snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_PLAYBACK_SRATE_176K);
-#endif /* DO_SOFT_AC3 */
}
}
}
-static void setup_spdif_playback(cmipci_t *cm, snd_pcm_substream_t *subs, int up, int do_ac3)
+static int setup_spdif_playback(cmipci_t *cm, snd_pcm_substream_t *subs, int up, int do_ac3)
{
- int rate;
- unsigned long flags;
+ int rate, err;
rate = subs->runtime->rate;
if (up && do_ac3)
- save_mixer_state(cm);
+ if ((err = save_mixer_state(cm)) < 0)
+ return err;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
cm->spdif_playback_avail = up;
if (up) {
/* they are controlled via "IEC958 Output Switch" */
snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_PLAYBACK_SPDF);
setup_ac3(cm, subs, 0, 0);
}
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
+ return 0;
}
{
cmipci_t *cm = snd_pcm_substream_chip(substream);
int rate = substream->runtime->rate;
- int do_spdif, do_ac3;
+ int err, do_spdif, do_ac3 = 0;
+
do_spdif = ((rate == 44100 || rate == 48000) &&
substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE &&
substream->runtime->channels == 2);
- do_ac3 = cm->dig_pcm_status & IEC958_AES0_NONAUDIO;
-#ifdef DO_SOFT_AC3
- if (do_ac3 && cm->can_ac3_sw)
- do_spdif = 0;
-#endif
- setup_spdif_playback(cm, substream, do_spdif, do_ac3);
+ if (do_spdif && cm->can_ac3_hw)
+ do_ac3 = cm->dig_pcm_status & IEC958_AES0_NONAUDIO;
+ if ((err = setup_spdif_playback(cm, substream, do_spdif, do_ac3)) < 0)
+ return err;
return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_PLAY], substream);
}
static int snd_cmipci_playback_spdif_prepare(snd_pcm_substream_t *substream)
{
cmipci_t *cm = snd_pcm_substream_chip(substream);
- setup_spdif_playback(cm, substream, 1, cm->dig_pcm_status & IEC958_AES0_NONAUDIO);
+ int err, do_ac3;
+
+ if (cm->can_ac3_hw)
+ do_ac3 = cm->dig_pcm_status & IEC958_AES0_NONAUDIO;
+ else
+ do_ac3 = 1; /* doesn't matter */
+ if ((err = setup_spdif_playback(cm, substream, 1, do_ac3)) < 0)
+ return err;
return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_PLAY], substream);
}
static int snd_cmipci_capture_spdif_prepare(snd_pcm_substream_t *substream)
{
cmipci_t *cm = snd_pcm_substream_chip(substream);
- unsigned long flags;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_CAPTURE_SPDF);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_CAPT], substream);
}
static int snd_cmipci_capture_spdif_hw_free(snd_pcm_substream_t *subs)
{
cmipci_t *cm = snd_pcm_substream_chip(subs);
- unsigned long flags;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_CAPTURE_SPDF);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return snd_cmipci_hw_free(subs);
}
*/
static irqreturn_t snd_cmipci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
- cmipci_t *cm = snd_magic_cast(cmipci_t, dev_id, return IRQ_NONE);
+ cmipci_t *cm = dev_id;
unsigned int status, mask = 0;
/* fastpath out, to ease interrupt sharing */
/* spdif playback on channel A */
static snd_pcm_hardware_t snd_cmipci_playback_spdif =
{
- .info = (SNDRV_PCM_INFO_INTERLEAVED |
- SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE),
+ .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE |
+ SNDRV_PCM_INFO_MMAP_VALID),
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
.rate_min = 44100,
.fifo_size = 0,
};
+/* spdif playback on channel A (32bit, IEC958 subframes) */
+static snd_pcm_hardware_t snd_cmipci_playback_iec958_subframe =
+{
+ .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE |
+ SNDRV_PCM_INFO_MMAP_VALID),
+ .formats = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE,
+ .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
+ .rate_min = 44100,
+ .rate_max = 48000,
+ .channels_min = 2,
+ .channels_max = 2,
+ .buffer_bytes_max = (128*1024),
+ .period_bytes_min = 64,
+ .period_bytes_max = (128*1024),
+ .periods_min = 2,
+ .periods_max = 1024,
+ .fifo_size = 0,
+};
+
/* spdif capture on channel B */
static snd_pcm_hardware_t snd_cmipci_capture_spdif =
{
*/
static int open_device_check(cmipci_t *cm, int mode, snd_pcm_substream_t *subs)
{
- unsigned long flags;
int ch = mode & CM_OPEN_CH_MASK;
/* FIXME: a file should wait until the device becomes free
if (! (mode & CM_OPEN_DAC)) {
/* disable dual DAC mode */
cm->channel[ch].is_dac = 0;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_ENDBDAC);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
}
up(&cm->open_mutex);
return 0;
static void close_device_check(cmipci_t *cm, int mode)
{
- unsigned long flags;
int ch = mode & CM_OPEN_CH_MASK;
down(&cm->open_mutex);
if (! cm->channel[ch].is_dac) {
/* enable dual DAC mode again */
cm->channel[ch].is_dac = 1;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_set_bit(cm, CM_REG_MISC_CTRL, CM_ENDBDAC);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
}
}
up(&cm->open_mutex);
if ((err = open_device_check(cm, CM_OPEN_SPDIF_PLAYBACK, substream)) < 0) /* use channel A */
return err;
- runtime->hw = snd_cmipci_playback_spdif;
-#ifdef DO_SOFT_AC3
- if (cm->can_ac3_hw)
-#endif
- runtime->hw.info |= SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID;
- if (cm->chip_version >= 37)
- runtime->hw.formats |= SNDRV_PCM_FMTBIT_S32_LE;
+ if (cm->can_ac3_hw) {
+ runtime->hw = snd_cmipci_playback_spdif;
+ if (cm->chip_version >= 37)
+ runtime->hw.formats |= SNDRV_PCM_FMTBIT_S32_LE;
+ } else {
+ runtime->hw = snd_cmipci_playback_iec958_subframe;
+ }
snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 0x40000);
cm->dig_pcm_status = cm->dig_status;
return 0;
.pointer = snd_cmipci_playback_pointer,
};
-#ifdef DO_SOFT_AC3
-static snd_pcm_ops_t snd_cmipci_playback_spdif_soft_ops = {
- .open = snd_cmipci_playback_spdif_open,
- .close = snd_cmipci_playback_spdif_close,
- .ioctl = snd_pcm_lib_ioctl,
- .hw_params = snd_cmipci_hw_params,
- .hw_free = snd_cmipci_playback_hw_free,
- .prepare = snd_cmipci_playback_spdif_prepare, /* set up rate */
- .trigger = snd_cmipci_playback_trigger,
- .pointer = snd_cmipci_playback_pointer,
- .copy = snd_cmipci_ac3_copy,
- .silence = snd_cmipci_ac3_silence,
-};
-#endif
-
static snd_pcm_ops_t snd_cmipci_capture_spdif_ops = {
.open = snd_cmipci_capture_spdif_open,
.close = snd_cmipci_capture_spdif_close,
if (err < 0)
return err;
-#ifdef DO_SOFT_AC3
- if (cm->can_ac3_hw)
- snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cmipci_playback_spdif_ops);
- else
- snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cmipci_playback_spdif_soft_ops);
-#else
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cmipci_playback_spdif_ops);
-#endif
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cmipci_capture_spdif_ops);
pcm->private_data = cm;
static int snd_cmipci_get_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
cmipci_sb_reg_t reg;
int val;
cmipci_sb_reg_decode(®, kcontrol->private_value);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
val = (snd_cmipci_mixer_read(cm, reg.left_reg) >> reg.left_shift) & reg.mask;
if (reg.invert)
val = reg.mask - val;
val = reg.mask - val;
ucontrol->value.integer.value[1] = val;
}
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return 0;
}
static int snd_cmipci_put_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
cmipci_sb_reg_t reg;
int change;
int left, right, oleft, oright;
right <<= reg.right_shift;
} else
right = 0;
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
oleft = snd_cmipci_mixer_read(cm, reg.left_reg);
left |= oleft & ~(reg.mask << reg.left_shift);
change = left != oleft;
snd_cmipci_mixer_write(cm, reg.right_reg, right);
} else
snd_cmipci_mixer_write(cm, reg.left_reg, left);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return change;
}
static int snd_cmipci_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
cmipci_sb_reg_t reg;
int val1, val2;
cmipci_sb_reg_decode(®, kcontrol->private_value);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
val1 = snd_cmipci_mixer_read(cm, reg.left_reg);
val2 = snd_cmipci_mixer_read(cm, reg.right_reg);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
ucontrol->value.integer.value[0] = (val1 >> reg.left_shift) & 1;
ucontrol->value.integer.value[1] = (val2 >> reg.left_shift) & 1;
ucontrol->value.integer.value[2] = (val1 >> reg.right_shift) & 1;
static int snd_cmipci_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
{
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
- unsigned long flags;
cmipci_sb_reg_t reg;
int change;
int val1, val2, oval1, oval2;
cmipci_sb_reg_decode(®, kcontrol->private_value);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
oval1 = snd_cmipci_mixer_read(cm, reg.left_reg);
oval2 = snd_cmipci_mixer_read(cm, reg.right_reg);
val1 = oval1 & ~((1 << reg.left_shift) | (1 << reg.right_shift));
change = val1 != oval1 || val2 != oval2;
snd_cmipci_mixer_write(cm, reg.left_reg, val1);
snd_cmipci_mixer_write(cm, reg.right_reg, val2);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return change;
}
{
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
cmipci_sb_reg_t reg;
- unsigned long flags;
unsigned char oreg, val;
cmipci_sb_reg_decode(®, kcontrol->private_value);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
oreg = inb(cm->iobase + reg.left_reg);
val = (oreg >> reg.left_shift) & reg.mask;
if (reg.invert)
val = reg.mask - val;
ucontrol->value.integer.value[1] = val;
}
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return 0;
}
{
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
cmipci_sb_reg_t reg;
- unsigned long flags;
unsigned char oreg, nreg, val;
cmipci_sb_reg_decode(®, kcontrol->private_value);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
oreg = inb(cm->iobase + reg.left_reg);
val = ucontrol->value.integer.value[0] & reg.mask;
if (reg.invert)
nreg |= (val << reg.right_shift);
}
outb(nreg, cm->iobase + reg.left_reg);
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return (nreg != oreg);
}
}
-#define num_controls(ary) (sizeof(ary) / sizeof(snd_kcontrol_new_t))
-
static snd_kcontrol_new_t snd_cmipci_mixers[] __devinitdata = {
CMIPCI_SB_VOL_STEREO("Master Playback Volume", SB_DSP4_MASTER_DEV, 3, 31),
CMIPCI_MIXER_SW_MONO("3D Control - Switch", CM_REG_MIXER1, CM_X3DEN_SHIFT, 0),
static int _snd_cmipci_uswitch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol, snd_cmipci_switch_args_t *args)
{
- unsigned long flags;
unsigned int val;
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
if (args->ac3_sensitive && cm->mixer_insensitive) {
ucontrol->value.integer.value[0] = 0;
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return 0;
}
if (args->is_byte)
else
val = snd_cmipci_read(cm, args->reg);
ucontrol->value.integer.value[0] = ((val & args->mask) == args->mask_on) ? 1 : 0;
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return 0;
}
static int _snd_cmipci_uswitch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol, snd_cmipci_switch_args_t *args)
{
- unsigned long flags;
unsigned int val;
int change;
cmipci_t *cm = snd_kcontrol_chip(kcontrol);
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
if (args->ac3_sensitive && cm->mixer_insensitive) {
/* ignored */
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return 0;
}
if (args->is_byte)
else
snd_cmipci_write(cm, args->reg, val);
}
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
return change;
}
static int __devinit snd_cmipci_mixer_new(cmipci_t *cm, int pcm_spdif_device)
{
- unsigned long flags;
snd_card_t *card;
snd_kcontrol_new_t *sw;
snd_kcontrol_t *kctl;
strcpy(card->mixername, "CMedia PCI");
- spin_lock_irqsave(&cm->reg_lock, flags);
+ spin_lock_irq(&cm->reg_lock);
snd_cmipci_mixer_write(cm, 0x00, 0x00); /* mixer reset */
- spin_unlock_irqrestore(&cm->reg_lock, flags);
+ spin_unlock_irq(&cm->reg_lock);
- for (idx = 0; idx < num_controls(snd_cmipci_mixers); idx++) {
+ for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_mixers); idx++) {
if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cmipci_mixers[idx], cm))) < 0)
return err;
}
/* mixer switches */
sw = snd_cmipci_mixer_switches;
- for (idx = 0; idx < num_controls(snd_cmipci_mixer_switches); idx++, sw++) {
+ for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_mixer_switches); idx++, sw++) {
err = snd_ctl_add(cm->card, snd_ctl_new1(sw, cm));
if (err < 0)
return err;
if (cm->device == PCI_DEVICE_ID_CMEDIA_CM8738 ||
cm->device == PCI_DEVICE_ID_CMEDIA_CM8738B) {
sw = snd_cmipci_8738_mixer_switches;
- for (idx = 0; idx < num_controls(snd_cmipci_8738_mixer_switches); idx++, sw++) {
+ for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_8738_mixer_switches); idx++, sw++) {
err = snd_ctl_add(cm->card, snd_ctl_new1(sw, cm));
if (err < 0)
return err;
}
- if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_cmipci_spdif_default, cm))) < 0)
- return err;
- kctl->id.device = pcm_spdif_device;
- if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_cmipci_spdif_mask, cm))) < 0)
- return err;
- kctl->id.device = pcm_spdif_device;
- if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_cmipci_spdif_stream, cm))) < 0)
- return err;
- kctl->id.device = pcm_spdif_device;
- cm->spdif_pcm_ctl = kctl;
+ if (cm->can_ac3_hw) {
+ if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_cmipci_spdif_default, cm))) < 0)
+ return err;
+ kctl->id.device = pcm_spdif_device;
+ if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_cmipci_spdif_mask, cm))) < 0)
+ return err;
+ kctl->id.device = pcm_spdif_device;
+ if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_cmipci_spdif_stream, cm))) < 0)
+ return err;
+ kctl->id.device = pcm_spdif_device;
+ }
if (cm->chip_version <= 37) {
sw = snd_cmipci_old_mixer_switches;
- for (idx = 0; idx < num_controls(snd_cmipci_old_mixer_switches); idx++, sw++) {
+ for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_old_mixer_switches); idx++, sw++) {
err = snd_ctl_add(cm->card, snd_ctl_new1(sw, cm));
if (err < 0)
return err;
}
if (cm->chip_version >= 39) {
sw = snd_cmipci_extra_mixer_switches;
- for (idx = 0; idx < num_controls(snd_cmipci_extra_mixer_switches); idx++, sw++) {
+ for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_extra_mixer_switches); idx++, sw++) {
err = snd_ctl_add(cm->card, snd_ctl_new1(sw, cm));
if (err < 0)
return err;
/* card switches */
sw = snd_cmipci_control_switches;
- for (idx = 0; idx < num_controls(snd_cmipci_control_switches); idx++, sw++) {
+ for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_control_switches); idx++, sw++) {
err = snd_ctl_add(cm->card, snd_ctl_new1(sw, cm));
if (err < 0)
return err;
static void snd_cmipci_proc_read(snd_info_entry_t *entry,
snd_info_buffer_t *buffer)
{
- cmipci_t *cm = snd_magic_cast(cmipci_t, entry->private_data, return);
+ cmipci_t *cm = entry->private_data;
int i;
snd_iprintf(buffer, "%s\n\n", cm->card->longname);
if (cm->can_multi_ch)
sprintf(cm->card->driver + strlen(cm->card->driver),
"-MC%d", cm->max_channels);
+ else if (cm->can_ac3_sw)
+ strcpy(cm->card->driver + strlen(cm->card->driver), "-SWIEC");
}
kfree_nocheck(cm->res_joystick);
}
#endif
- if (cm->res_iobase) {
- release_resource(cm->res_iobase);
- kfree_nocheck(cm->res_iobase);
- }
- snd_magic_kfree(cm);
+ pci_release_regions(cm->pci);
+ kfree(cm);
return 0;
}
static int snd_cmipci_dev_free(snd_device_t *device)
{
- cmipci_t *cm = snd_magic_cast(cmipci_t, device->device_data, return -ENXIO);
+ cmipci_t *cm = device->device_data;
return snd_cmipci_free(cm);
}
if ((err = pci_enable_device(pci)) < 0)
return err;
- cm = snd_magic_kcalloc(cmipci_t, 0, GFP_KERNEL);
+ cm = kcalloc(1, sizeof(*cm), GFP_KERNEL);
if (cm == NULL)
return -ENOMEM;
cm->card = card;
cm->pci = pci;
cm->irq = -1;
- cm->iobase = pci_resource_start(pci, 0);
cm->channel[0].ch = 0;
cm->channel[1].ch = 1;
cm->channel[0].is_dac = cm->channel[1].is_dac = 1; /* dual DAC mode */
- if ((cm->res_iobase = request_region(cm->iobase, CM_EXTENT_CODEC, card->driver)) == NULL) {
- snd_printk("unable to grab ports 0x%lx-0x%lx\n", cm->iobase, cm->iobase + CM_EXTENT_CODEC - 1);
- err = -EBUSY;
- goto __error;
+ if ((err = pci_request_regions(pci, card->driver)) < 0) {
+ kfree(cm);
+ return err;
}
+ cm->iobase = pci_resource_start(pci, 0);
+
if (request_irq(pci->irq, snd_cmipci_interrupt, SA_INTERRUPT|SA_SHIRQ, card->driver, (void *)cm)) {
snd_printk("unable to grab IRQ %d\n", pci->irq);
err = -EBUSY;
cm->chip_version = 0;
cm->max_channels = 2;
-#ifdef DO_SOFT_AC3
cm->do_soft_ac3 = soft_ac3[dev];
-#endif
query_chip(cm);
int i;
for (i = 0; ports[i]; i++) {
joystick_port[dev] = ports[i];
- cm->res_joystick = request_region(ports[i], 8, "CMIPCI gameport");
+ cm->res_joystick = request_region(ports[i], 1, "CMIPCI gameport");
if (cm->res_joystick)
break;
}
} else {
- cm->res_joystick = request_region(joystick_port[dev], 8, "CMIPCI gameport");
+ cm->res_joystick = request_region(joystick_port[dev], 1, "CMIPCI gameport");
}
}
if (cm->res_joystick) {
static int __init alsa_card_cmipci_init(void)
{
- int err;
-
- if ((err = pci_module_init(&driver)) < 0) {
-#ifdef MODULE
- printk(KERN_ERR "C-Media PCI soundcard not found or device busy\n");
-#endif
- return err;
- }
- return 0;
+ return pci_module_init(&driver);
}
static void __exit alsa_card_cmipci_exit(void)
module_init(alsa_card_cmipci_init)
module_exit(alsa_card_cmipci_exit)
-
-#ifndef MODULE
-
-/* format is: snd-cmipci=enable,index,id,
- mpu_port,fm_port,soft_ac3,joystick_port */
-
-static int __init alsa_card_cmipci_setup(char *str)
-{
- static unsigned __initdata nr_dev = 0;
-
- if (nr_dev >= SNDRV_CARDS)
- return 0;
- (void)(get_option(&str,&enable[nr_dev]) == 2 &&
- get_option(&str,&index[nr_dev]) == 2 &&
- get_id(&str,&id[nr_dev]) == 2 &&
- get_option_long(&str,&mpu_port[nr_dev]) == 2 &&
- get_option_long(&str,&fm_port[nr_dev]) == 2
-#ifdef DO_SOFT_AC3
- && get_option(&str,&soft_ac3[nr_dev]) == 2
-#endif
-#ifdef SUPPORT_JOYSTICK
- && get_option(&str,&joystick_port[nr_dev]) == 2
-#endif
- );
- nr_dev++;
- return 1;
-}
-
-__setup("snd-cmipci=", alsa_card_cmipci_setup);
-
-#endif /* ifndef MODULE */
git://git.onelab.eu / linux-2.6.git / blobdiff