diff options
Diffstat (limited to 'sound/oss/opl3sa2.c')
| -rw-r--r-- | sound/oss/opl3sa2.c | 1129 |
1 files changed, 1129 insertions, 0 deletions
diff --git a/sound/oss/opl3sa2.c b/sound/oss/opl3sa2.c new file mode 100644 index 000000000000..7b4996e71576 --- /dev/null +++ b/sound/oss/opl3sa2.c @@ -0,0 +1,1129 @@ +/* + * sound/opl3sa2.c + * + * A low level driver for Yamaha OPL3-SA2 and SA3 cards. + * NOTE: All traces of the name OPL3-SAx have now (December 2000) been + * removed from the driver code, as an email exchange with Yamaha + * provided the information that the YMF-719 is indeed just a + * re-badged 715. + * + * Copyright 1998-2001 Scott Murray <scott@spiteful.org> + * + * Originally based on the CS4232 driver (in cs4232.c) by Hannu Savolainen + * and others. Now incorporates code/ideas from pss.c, also by Hannu + * Savolainen. Both of those files are distributed with the following + * license: + * + * "Copyright (C) by Hannu Savolainen 1993-1997 + * + * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) + * Version 2 (June 1991). See the "COPYING" file distributed with this software + * for more info." + * + * As such, in accordance with the above license, this file, opl3sa2.c, is + * distributed under the GNU GENERAL PUBLIC LICENSE (GPL) Version 2 (June 1991). + * See the "COPYING" file distributed with this software for more information. + * + * Change History + * -------------- + * Scott Murray Original driver (Jun 14, 1998) + * Paul J.Y. Lahaie Changed probing / attach code order + * Scott Murray Added mixer support (Dec 03, 1998) + * Scott Murray Changed detection code to be more forgiving, + * added force option as last resort, + * fixed ioctl return values. (Dec 30, 1998) + * Scott Murray Simpler detection code should work all the time now + * (with thanks to Ben Hutchings for the heuristic), + * removed now unnecessary force option. (Jan 5, 1999) + * Christoph Hellwig Adapted to module_init/module_exit (Mar 4, 2000) + * Scott Murray Reworked SA2 versus SA3 mixer code, updated chipset + * version detection code (again!). (Dec 5, 2000) + * Scott Murray Adjusted master volume mixer scaling. (Dec 6, 2000) + * Scott Murray Based on a patch by Joel Yliluoma (aka Bisqwit), + * integrated wide mixer and adjusted mic, bass, treble + * scaling. (Dec 6, 2000) + * Scott Murray Based on a patch by Peter Englmaier, integrated + * ymode and loopback options. (Dec 6, 2000) + * Scott Murray Inspired by a patch by Peter Englmaier, and based on + * what ALSA does, added initialization code for the + * default DMA and IRQ settings. (Dec 6, 2000) + * Scott Murray Added some more checks to the card detection code, + * based on what ALSA does. (Dec 12, 2000) + * Scott Murray Inspired by similar patches from John Fremlin, + * Jim Radford, Mike Rolig, and Ingmar Steen, added 2.4 + * ISA PnP API support, mainly based on bits from + * sb_card.c and awe_wave.c. (Dec 12, 2000) + * Scott Murray Some small cleanups to the init code output. + * (Jan 7, 2001) + * Zwane Mwaikambo Added PM support. (Dec 4 2001) + * + * Adam Belay Converted driver to new PnP Layer (Oct 12, 2002) + * Zwane Mwaikambo Code, data structure cleanups. (Feb 15 2002) + * Zwane Mwaikambo Free resources during auxiliary device probe + * failures (Apr 29 2002) + * + */ + +#include <linux/config.h> +#include <linux/pnp.h> +#include <linux/init.h> +#include <linux/module.h> +#include <linux/delay.h> +#include <linux/pm.h> +#include "sound_config.h" + +#include "ad1848.h" +#include "mpu401.h" + +#define OPL3SA2_MODULE_NAME "opl3sa2" +#define PFX OPL3SA2_MODULE_NAME ": " + +/* Useful control port indexes: */ +#define OPL3SA2_PM 0x01 +#define OPL3SA2_SYS_CTRL 0x02 +#define OPL3SA2_IRQ_CONFIG 0x03 +#define OPL3SA2_DMA_CONFIG 0x06 +#define OPL3SA2_MASTER_LEFT 0x07 +#define OPL3SA2_MASTER_RIGHT 0x08 +#define OPL3SA2_MIC 0x09 +#define OPL3SA2_MISC 0x0A + +#define OPL3SA3_WIDE 0x14 +#define OPL3SA3_BASS 0x15 +#define OPL3SA3_TREBLE 0x16 + +/* Useful constants: */ +#define DEFAULT_VOLUME 50 +#define DEFAULT_MIC 50 +#define DEFAULT_TIMBRE 0 + +/* Power saving modes */ +#define OPL3SA2_PM_MODE0 0x00 +#define OPL3SA2_PM_MODE1 0x04 /* PSV */ +#define OPL3SA2_PM_MODE2 0x05 /* PSV | PDX */ +#define OPL3SA2_PM_MODE3 0x27 /* ADOWN | PSV | PDN | PDX */ + + +/* For checking against what the card returns: */ +#define VERSION_UNKNOWN 0 +#define VERSION_YMF711 1 +#define VERSION_YMF715 2 +#define VERSION_YMF715B 3 +#define VERSION_YMF715E 4 +/* also assuming that anything > 4 but <= 7 is a 715E */ + +/* Chipset type constants for use below */ +#define CHIPSET_UNKNOWN -1 +#define CHIPSET_OPL3SA2 0 +#define CHIPSET_OPL3SA3 1 +static const char *CHIPSET_TABLE[] = {"OPL3-SA2", "OPL3-SA3"}; + +#ifdef CONFIG_PNP +#define OPL3SA2_CARDS_MAX 4 +#else +#define OPL3SA2_CARDS_MAX 1 +#endif + +/* This should be pretty obvious */ +static int opl3sa2_cards_num; + +typedef struct { + /* device resources */ + unsigned short cfg_port; + struct address_info cfg; + struct address_info cfg_mss; + struct address_info cfg_mpu; +#ifdef CONFIG_PNP + /* PnP Stuff */ + struct pnp_dev* pdev; + int activated; /* Whether said devices have been activated */ +#endif +#ifdef CONFIG_PM + unsigned int in_suspend; + struct pm_dev *pmdev; +#endif + unsigned int card; + int chipset; /* What's my version(s)? */ + char *chipset_name; + + /* mixer data */ + int mixer; + unsigned int volume_l; + unsigned int volume_r; + unsigned int mic; + unsigned int bass_l; + unsigned int bass_r; + unsigned int treble_l; + unsigned int treble_r; + unsigned int wide_l; + unsigned int wide_r; +} opl3sa2_state_t; +static opl3sa2_state_t opl3sa2_state[OPL3SA2_CARDS_MAX]; + + + +/* Our parameters */ +static int __initdata io = -1; +static int __initdata mss_io = -1; +static int __initdata mpu_io = -1; +static int __initdata irq = -1; +static int __initdata dma = -1; +static int __initdata dma2 = -1; +static int __initdata ymode = -1; +static int __initdata loopback = -1; + +#ifdef CONFIG_PNP +/* PnP specific parameters */ +static int __initdata isapnp = 1; +static int __initdata multiple = 1; + +/* Whether said devices have been activated */ +static int opl3sa2_activated[OPL3SA2_CARDS_MAX]; +#else +static int __initdata isapnp; /* = 0 */ +static int __initdata multiple; /* = 0 */ +#endif + +MODULE_DESCRIPTION("Module for OPL3-SA2 and SA3 sound cards (uses AD1848 MSS driver)."); +MODULE_AUTHOR("Scott Murray <scott@spiteful.org>"); +MODULE_LICENSE("GPL"); + + +module_param(io, int, 0); +MODULE_PARM_DESC(io, "Set I/O base of OPL3-SA2 or SA3 card (usually 0x370. Address must be even and must be from 0x100 to 0xFFE)"); + +module_param(mss_io, int, 0); +MODULE_PARM_DESC(mss_io, "Set MSS (audio) I/O base (0x530, 0xE80, or other. Address must end in 0 or 4 and must be from 0x530 to 0xF48)"); + +module_param(mpu_io, int, 0); +MODULE_PARM_DESC(mpu_io, "Set MIDI I/O base (0x330 or other. Address must be even and must be from 0x300 to 0x334)"); + +module_param(irq, int, 0); +MODULE_PARM_DESC(mss_irq, "Set MSS (audio) IRQ (5, 7, 9, 10, 11, 12)"); + +module_param(dma, int, 0); +MODULE_PARM_DESC(dma, "Set MSS (audio) first DMA channel (0, 1, 3)"); + +module_param(dma2, int, 0); +MODULE_PARM_DESC(dma2, "Set MSS (audio) second DMA channel (0, 1, 3)"); + +module_param(ymode, int, 0); +MODULE_PARM_DESC(ymode, "Set Yamaha 3D enhancement mode (0 = Desktop/Normal, 1 = Notebook PC (1), 2 = Notebook PC (2), 3 = Hi-Fi)"); + +module_param(loopback, int, 0); +MODULE_PARM_DESC(loopback, "Set A/D input source. Useful for echo cancellation (0 = Mic Rch (default), 1 = Mono output loopback)"); + +#ifdef CONFIG_PNP +module_param(isapnp, bool, 0); +MODULE_PARM_DESC(isapnp, "When set to 0, ISA PnP support will be disabled"); + +module_param(multiple, bool, 0); +MODULE_PARM_DESC(multiple, "When set to 0, will not search for multiple cards"); +#endif + + +/* + * Standard read and write functions +*/ + +static inline void opl3sa2_write(unsigned short port, + unsigned char index, + unsigned char data) +{ + outb_p(index, port); + outb(data, port + 1); +} + + +static inline void opl3sa2_read(unsigned short port, + unsigned char index, + unsigned char* data) +{ + outb_p(index, port); + *data = inb(port + 1); +} + + +/* + * All of the mixer functions... + */ + +static void opl3sa2_set_volume(opl3sa2_state_t* devc, int left, int right) +{ + static unsigned char scale[101] = { + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, + 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00 + }; + unsigned char vol; + + vol = scale[left]; + + /* If level is zero, turn on mute */ + if(!left) + vol |= 0x80; + + opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_LEFT, vol); + + vol = scale[right]; + + /* If level is zero, turn on mute */ + if(!right) + vol |= 0x80; + + opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_RIGHT, vol); +} + + +static void opl3sa2_set_mic(opl3sa2_state_t* devc, int level) +{ + unsigned char vol = 0x1F; + + if((level >= 0) && (level <= 100)) + vol = 0x1F - (unsigned char) (32 * level / 101); + + /* If level is zero, turn on mute */ + if(!level) + vol |= 0x80; + + opl3sa2_write(devc->cfg_port, OPL3SA2_MIC, vol); +} + + +static void opl3sa3_set_bass(opl3sa2_state_t* devc, int left, int right) +{ + unsigned char bass; + + bass = left ? ((unsigned char) (8 * left / 101)) : 0; + bass |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4; + + opl3sa2_write(devc->cfg_port, OPL3SA3_BASS, bass); +} + + +static void opl3sa3_set_treble(opl3sa2_state_t* devc, int left, int right) +{ + unsigned char treble; + + treble = left ? ((unsigned char) (8 * left / 101)) : 0; + treble |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4; + + opl3sa2_write(devc->cfg_port, OPL3SA3_TREBLE, treble); +} + + + + +static void opl3sa2_mixer_reset(opl3sa2_state_t* devc) +{ + if (devc) { + opl3sa2_set_volume(devc, DEFAULT_VOLUME, DEFAULT_VOLUME); + devc->volume_l = devc->volume_r = DEFAULT_VOLUME; + + opl3sa2_set_mic(devc, DEFAULT_MIC); + devc->mic = DEFAULT_MIC; + + if (devc->chipset == CHIPSET_OPL3SA3) { + opl3sa3_set_bass(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE); + devc->bass_l = devc->bass_r = DEFAULT_TIMBRE; + opl3sa3_set_treble(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE); + devc->treble_l = devc->treble_r = DEFAULT_TIMBRE; + } + } +} + +/* Currently only used for power management */ +#ifdef CONFIG_PM +static void opl3sa2_mixer_restore(opl3sa2_state_t* devc) +{ + if (devc) { + opl3sa2_set_volume(devc, devc->volume_l, devc->volume_r); + opl3sa2_set_mic(devc, devc->mic); + + if (devc->chipset == CHIPSET_OPL3SA3) { + opl3sa3_set_bass(devc, devc->bass_l, devc->bass_r); + opl3sa3_set_treble(devc, devc->treble_l, devc->treble_r); + } + } +} +#endif + +static inline void arg_to_vol_mono(unsigned int vol, int* value) +{ + int left; + + left = vol & 0x00ff; + if (left > 100) + left = 100; + *value = left; +} + + +static inline void arg_to_vol_stereo(unsigned int vol, int* aleft, int* aright) +{ + arg_to_vol_mono(vol, aleft); + arg_to_vol_mono(vol >> 8, aright); +} + + +static inline int ret_vol_mono(int vol) +{ + return ((vol << 8) | vol); +} + + +static inline int ret_vol_stereo(int left, int right) +{ + return ((right << 8) | left); +} + + +static int opl3sa2_mixer_ioctl(int dev, unsigned int cmd, void __user *arg) +{ + int retval, value, cmdf = cmd & 0xff; + int __user *p = (int __user *)arg; + + opl3sa2_state_t* devc = &opl3sa2_state[dev]; + + switch (cmdf) { + case SOUND_MIXER_VOLUME: + case SOUND_MIXER_MIC: + case SOUND_MIXER_DEVMASK: + case SOUND_MIXER_STEREODEVS: + case SOUND_MIXER_RECMASK: + case SOUND_MIXER_RECSRC: + case SOUND_MIXER_CAPS: + break; + + default: + return -EINVAL; + } + + if (((cmd >> 8) & 0xff) != 'M') + return -EINVAL; + + retval = 0; + if (_SIOC_DIR (cmd) & _SIOC_WRITE) { + switch (cmdf) { + case SOUND_MIXER_VOLUME: + retval = get_user(value, (unsigned __user *) arg); + if (retval) + break; + arg_to_vol_stereo(value, &devc->volume_l, &devc->volume_r); + opl3sa2_set_volume(devc, devc->volume_l, devc->volume_r); + value = ret_vol_stereo(devc->volume_l, devc->volume_r); + retval = put_user(value, p); + break; + + case SOUND_MIXER_MIC: + retval = get_user(value, (unsigned __user *) arg); + if (retval) + break; + arg_to_vol_mono(value, &devc->mic); + opl3sa2_set_mic(devc, devc->mic); + value = ret_vol_mono(devc->mic); + retval = put_user(value, p); + break; + + default: + retval = -EINVAL; + } + } + else { + /* + * Return parameters + */ + switch (cmdf) { + case SOUND_MIXER_DEVMASK: + retval = put_user(SOUND_MASK_VOLUME | SOUND_MASK_MIC, p); + break; + + case SOUND_MIXER_STEREODEVS: + retval = put_user(SOUND_MASK_VOLUME, p); + break; + + case SOUND_MIXER_RECMASK: + /* No recording devices */ + retval = put_user(0, p); + break; + + case SOUND_MIXER_CAPS: + retval = put_user(SOUND_CAP_EXCL_INPUT, p); + break; + + case SOUND_MIXER_RECSRC: + /* No recording source */ + retval = put_user(0, p); + break; + + case SOUND_MIXER_VOLUME: + value = ret_vol_stereo(devc->volume_l, devc->volume_r); + retval = put_user(value, p); + break; + + case SOUND_MIXER_MIC: + value = ret_vol_mono(devc->mic); + put_user(value, p); + break; + + default: + retval = -EINVAL; + } + } + return retval; +} +/* opl3sa2_mixer_ioctl end */ + + +static int opl3sa3_mixer_ioctl(int dev, unsigned int cmd, void __user * arg) +{ + int value, retval, cmdf = cmd & 0xff; + + opl3sa2_state_t* devc = &opl3sa2_state[dev]; + + switch (cmdf) { + case SOUND_MIXER_BASS: + value = ret_vol_stereo(devc->bass_l, devc->bass_r); + retval = put_user(value, (int __user *) arg); + break; + + case SOUND_MIXER_TREBLE: + value = ret_vol_stereo(devc->treble_l, devc->treble_r); + retval = put_user(value, (int __user *) arg); + break; + + case SOUND_MIXER_DIGITAL1: + value = ret_vol_stereo(devc->wide_l, devc->wide_r); + retval = put_user(value, (int __user *) arg); + break; + + default: + retval = -EINVAL; + } + return retval; +} +/* opl3sa3_mixer_ioctl end */ + + +static struct mixer_operations opl3sa2_mixer_operations = +{ + .owner = THIS_MODULE, + .id = "OPL3-SA2", + .name = "Yamaha OPL3-SA2", + .ioctl = opl3sa2_mixer_ioctl +}; + +static struct mixer_operations opl3sa3_mixer_operations = +{ + .owner = THIS_MODULE, + .id = "OPL3-SA3", + .name = "Yamaha OPL3-SA3", + .ioctl = opl3sa3_mixer_ioctl +}; + +/* End of mixer-related stuff */ + + +/* + * Component probe, attach, unload functions + */ + +static inline void __exit unload_opl3sa2_mpu(struct address_info *hw_config) +{ + unload_mpu401(hw_config); +} + + +static void __init attach_opl3sa2_mss(struct address_info* hw_config, struct resource *ports) +{ + int initial_mixers; + + initial_mixers = num_mixers; + attach_ms_sound(hw_config, ports, THIS_MODULE); /* Slot 0 */ + if (hw_config->slots[0] != -1) { + /* Did the MSS driver install? */ + if(num_mixers == (initial_mixers + 1)) { + /* The MSS mixer is installed, reroute mixers appropiately */ + AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_CD); + AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_SYNTH); + AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_LINE); + } + else { + printk(KERN_ERR PFX "MSS mixer not installed?\n"); + } + } +} + + +static inline void __exit unload_opl3sa2_mss(struct address_info* hw_config) +{ + unload_ms_sound(hw_config); +} + + +static int __init probe_opl3sa2(struct address_info* hw_config, int card) +{ + unsigned char misc; + unsigned char tmp; + unsigned char version; + + /* + * Try and allocate our I/O port range. + */ + if (!request_region(hw_config->io_base, 2, OPL3SA2_MODULE_NAME)) { + printk(KERN_ERR PFX "Control I/O port %#x not free\n", + hw_config->io_base); + goto out_nodev; + } + + /* + * Check if writing to the read-only version bits of the miscellaneous + * register succeeds or not (it should not). + */ + opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc); + opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc ^ 0x07); + opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &tmp); + if(tmp != misc) { + printk(KERN_ERR PFX "Control I/O port %#x is not a YMF7xx chipset!\n", + hw_config->io_base); + goto out_region; + } + + /* + * Check if the MIC register is accessible. + */ + opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp); + opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, 0x8a); + opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp); + if((tmp & 0x9f) != 0x8a) { + printk(KERN_ERR + PFX "Control I/O port %#x is not a YMF7xx chipset!\n", + hw_config->io_base); + goto out_region; + } + opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, tmp); + + /* + * Determine chipset type (SA2 or SA3) + * + * This is done by looking at the chipset version in the lower 3 bits + * of the miscellaneous register. + */ + version = misc & 0x07; + printk(KERN_DEBUG PFX "Chipset version = %#x\n", version); + switch (version) { + case 0: + opl3sa2_state[card].chipset = CHIPSET_UNKNOWN; + printk(KERN_ERR + PFX "Unknown Yamaha audio controller version\n"); + break; + + case VERSION_YMF711: + opl3sa2_state[card].chipset = CHIPSET_OPL3SA2; + printk(KERN_INFO PFX "Found OPL3-SA2 (YMF711)\n"); + break; + + case VERSION_YMF715: + opl3sa2_state[card].chipset = CHIPSET_OPL3SA3; + printk(KERN_INFO + PFX "Found OPL3-SA3 (YMF715 or YMF719)\n"); + break; + + case VERSION_YMF715B: + opl3sa2_state[card].chipset = CHIPSET_OPL3SA3; + printk(KERN_INFO + PFX "Found OPL3-SA3 (YMF715B or YMF719B)\n"); + break; + + case VERSION_YMF715E: + default: + opl3sa2_state[card].chipset = CHIPSET_OPL3SA3; + printk(KERN_INFO + PFX "Found OPL3-SA3 (YMF715E or YMF719E)\n"); + break; + } + + if (opl3sa2_state[card].chipset != CHIPSET_UNKNOWN) { + /* Generate a pretty name */ + opl3sa2_state[card].chipset_name = (char *)CHIPSET_TABLE[opl3sa2_state[card].chipset]; + return 0; + } + +out_region: + release_region(hw_config->io_base, 2); +out_nodev: + return -ENODEV; +} + + +static void __init attach_opl3sa2(struct address_info* hw_config, int card) +{ + /* Initialize IRQ configuration to IRQ-B: -, IRQ-A: WSS+MPU+OPL3 */ + opl3sa2_write(hw_config->io_base, OPL3SA2_IRQ_CONFIG, 0x0d); + + /* Initialize DMA configuration */ + if(hw_config->dma2 == hw_config->dma) { + /* Want DMA configuration DMA-B: -, DMA-A: WSS-P+WSS-R */ + opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x03); + } + else { + /* Want DMA configuration DMA-B: WSS-R, DMA-A: WSS-P */ + opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x21); + } +} + + +static void __init attach_opl3sa2_mixer(struct address_info *hw_config, int card) +{ + struct mixer_operations* mixer_operations; + opl3sa2_state_t* devc = &opl3sa2_state[card]; + + /* Install master mixer */ + if (devc->chipset == CHIPSET_OPL3SA3) { + mixer_operations = &opl3sa3_mixer_operations; + } + else { + mixer_operations = &opl3sa2_mixer_operations; + } + + devc->cfg_port = hw_config->io_base; + devc->mixer = sound_install_mixer(MIXER_DRIVER_VERSION, + mixer_operations->name, + mixer_operations, + sizeof(struct mixer_operations), + devc); + if(devc->mixer < 0) { + printk(KERN_ERR PFX "Could not install %s master mixer\n", + mixer_operations->name); + } + else { + opl3sa2_mixer_reset(devc); + + } +} + + +static void opl3sa2_clear_slots(struct address_info* hw_config) +{ + int i; + + for(i = 0; i < 6; i++) { + hw_config->slots[i] = -1; + } +} + + +static void __init opl3sa2_set_ymode(struct address_info* hw_config, int ymode) +{ + /* + * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and + * it's supported. + * + * 0: Desktop (aka normal) 5-12 cm speakers + * 1: Notebook PC mode 1 3 cm speakers + * 2: Notebook PC mode 2 1.5 cm speakers + * 3: Hi-fi 16-38 cm speakers + */ + if(ymode >= 0 && ymode <= 3) { + unsigned char sys_ctrl; + + opl3sa2_read(hw_config->io_base, OPL3SA2_SYS_CTRL, &sys_ctrl); + sys_ctrl = (sys_ctrl & 0xcf) | ((ymode & 3) << 4); + opl3sa2_write(hw_config->io_base, OPL3SA2_SYS_CTRL, sys_ctrl); + } + else { + printk(KERN_ERR PFX "not setting ymode, it must be one of 0,1,2,3\n"); + } +} + + +static void __init opl3sa2_set_loopback(struct address_info* hw_config, int loopback) +{ + if(loopback >= 0 && loopback <= 1) { + unsigned char misc; + + opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc); + misc = (misc & 0xef) | ((loopback & 1) << 4); + opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc); + } + else { + printk(KERN_ERR PFX "not setting loopback, it must be either 0 or 1\n"); + } +} + + +static void __exit unload_opl3sa2(struct address_info* hw_config, int card) +{ + /* Release control ports */ + release_region(hw_config->io_base, 2); + + /* Unload mixer */ + if(opl3sa2_state[card].mixer >= 0) + sound_unload_mixerdev(opl3sa2_state[card].mixer); + +} + +#ifdef CONFIG_PNP +static struct pnp_device_id pnp_opl3sa2_list[] = { + {.id = "YMH0021", .driver_data = 0}, + {.id = ""} +}; + +MODULE_DEVICE_TABLE(pnp, pnp_opl3sa2_list); + +static int opl3sa2_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id) +{ + int card = opl3sa2_cards_num; + + /* we don't actually want to return an error as the user may have specified + * no multiple card search + */ + + if (opl3sa2_cards_num == OPL3SA2_CARDS_MAX) + return 0; + opl3sa2_activated[card] = 1; + + /* Our own config: */ + opl3sa2_state[card].cfg.io_base = pnp_port_start(dev, 4); + opl3sa2_state[card].cfg.irq = pnp_irq(dev, 0); + opl3sa2_state[card].cfg.dma = pnp_dma(dev, 0); + opl3sa2_state[card].cfg.dma2 = pnp_dma(dev, 1); + + /* The MSS config: */ + opl3sa2_state[card].cfg_mss.io_base = pnp_port_start(dev, 1); + opl3sa2_state[card].cfg_mss.irq = pnp_irq(dev, 0); + opl3sa2_state[card].cfg_mss.dma = pnp_dma(dev, 0); + opl3sa2_state[card].cfg_mss.dma2 = pnp_dma(dev, 1); + opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */ + + opl3sa2_state[card].cfg_mpu.io_base = pnp_port_start(dev, 3); + opl3sa2_state[card].cfg_mpu.irq = pnp_irq(dev, 0); + opl3sa2_state[card].cfg_mpu.dma = -1; + opl3sa2_state[card].cfg_mpu.dma2 = -1; + opl3sa2_state[card].cfg_mpu.always_detect = 1; /* It's there, so use shared IRQs */ + + /* Call me paranoid: */ + opl3sa2_clear_slots(&opl3sa2_state[card].cfg); + opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss); + opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu); + + opl3sa2_state[card].pdev = dev; + opl3sa2_cards_num++; + + return 0; +} + +static struct pnp_driver opl3sa2_driver = { + .name = "opl3sa2", + .id_table = pnp_opl3sa2_list, + .probe = opl3sa2_pnp_probe, +}; + +#endif /* CONFIG_PNP */ + +/* End of component functions */ + +#ifdef CONFIG_PM +static DEFINE_SPINLOCK(opl3sa2_lock); + +/* Power Management support functions */ +static int opl3sa2_suspend(struct pm_dev *pdev, unsigned int pm_mode) +{ + unsigned long flags; + opl3sa2_state_t *p; + + if (!pdev) + return -EINVAL; + + spin_lock_irqsave(&opl3sa2_lock,flags); + + p = (opl3sa2_state_t *) pdev->data; + switch (pm_mode) { + case 1: + pm_mode = OPL3SA2_PM_MODE1; + break; + case 2: + pm_mode = OPL3SA2_PM_MODE2; + break; + case 3: + pm_mode = OPL3SA2_PM_MODE3; + break; + default: + /* we don't know howto handle this... */ + spin_unlock_irqrestore(&opl3sa2_lock, flags); + return -EBUSY; + } + + p->in_suspend = 1; + + /* its supposed to automute before suspending, so we won't bother */ + opl3sa2_write(p->cfg_port, OPL3SA2_PM, pm_mode); + /* wait a while for the clock oscillator to stabilise */ + mdelay(10); + + spin_unlock_irqrestore(&opl3sa2_lock,flags); + return 0; +} + +static int opl3sa2_resume(struct pm_dev *pdev) +{ + unsigned long flags; + opl3sa2_state_t *p; + + if (!pdev) + return -EINVAL; + + p = (opl3sa2_state_t *) pdev->data; + spin_lock_irqsave(&opl3sa2_lock,flags); + + /* I don't think this is necessary */ + opl3sa2_write(p->cfg_port, OPL3SA2_PM, OPL3SA2_PM_MODE0); + opl3sa2_mixer_restore(p); + p->in_suspend = 0; + + spin_unlock_irqrestore(&opl3sa2_lock,flags); + return 0; +} + +static int opl3sa2_pm_callback(struct pm_dev *pdev, pm_request_t rqst, void *data) +{ + unsigned long mode = (unsigned long)data; + + switch (rqst) { + case PM_SUSPEND: + return opl3sa2_suspend(pdev, mode); + + case PM_RESUME: + return opl3sa2_resume(pdev); + } + return 0; +} +#endif /* CONFIG_PM */ + +/* + * Install OPL3-SA2 based card(s). + * + * Need to have ad1848 and mpu401 loaded ready. + */ +static int __init init_opl3sa2(void) +{ + int card, max; + + /* Sanitize isapnp and multiple settings */ + isapnp = isapnp != 0 ? 1 : 0; + multiple = multiple != 0 ? 1 : 0; + + max = (multiple && isapnp) ? OPL3SA2_CARDS_MAX : 1; + +#ifdef CONFIG_PNP + if (isapnp){ + pnp_register_driver(&opl3sa2_driver); + if(!opl3sa2_cards_num){ + printk(KERN_INFO PFX "No PnP cards found\n"); + isapnp = 0; + } + max = opl3sa2_cards_num; + } +#endif + + for (card = 0; card < max; card++) { + /* If a user wants an I/O then assume they meant it */ + struct resource *ports; + int base; + + if (!isapnp) { + if (io == -1 || irq == -1 || dma == -1 || + dma2 == -1 || mss_io == -1) { + printk(KERN_ERR + PFX "io, mss_io, irq, dma, and dma2 must be set\n"); + return -EINVAL; + } + opl3sa2_cards_num++; + + /* + * Our own config: + * (NOTE: IRQ and DMA aren't used, so they're set to + * give pretty output from conf_printf. :) + */ + opl3sa2_state[card].cfg.io_base = io; + opl3sa2_state[card].cfg.irq = irq; + opl3sa2_state[card].cfg.dma = dma; + opl3sa2_state[card].cfg.dma2 = dma2; + + /* The MSS config: */ + opl3sa2_state[card].cfg_mss.io_base = mss_io; + opl3sa2_state[card].cfg_mss.irq = irq; + opl3sa2_state[card].cfg_mss.dma = dma; + opl3sa2_state[card].cfg_mss.dma2 = dma2; + opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */ + + opl3sa2_state[card].cfg_mpu.io_base = mpu_io; + opl3sa2_state[card].cfg_mpu.irq = irq; + opl3sa2_state[card].cfg_mpu.dma = -1; + opl3sa2_state[card].cfg_mpu.always_detect = 1; /* Use shared IRQs */ + + /* Call me paranoid: */ + opl3sa2_clear_slots(&opl3sa2_state[card].cfg); + opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss); + opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu); + } + + /* FIXME: leak */ + if (probe_opl3sa2(&opl3sa2_state[card].cfg, card)) + return -ENODEV; + + base = opl3sa2_state[card].cfg_mss.io_base; + + if (!request_region(base, 4, "WSS config")) + goto failed; + + ports = request_region(base + 4, 4, "ad1848"); + if (!ports) + goto failed2; + + if (!probe_ms_sound(&opl3sa2_state[card].cfg_mss, ports)) { + /* + * If one or more cards are already registered, don't + * return an error but print a warning. Note, this + * should never really happen unless the hardware or + * ISA PnP screwed up. + */ + release_region(base + 4, 4); + failed2: + release_region(base, 4); + failed: + release_region(opl3sa2_state[card].cfg.io_base, 2); + + if (opl3sa2_cards_num) { + printk(KERN_WARNING + PFX "There was a problem probing one " + " of the ISA PNP cards, continuing\n"); + opl3sa2_cards_num--; + continue; + } else + return -ENODEV; + } + + attach_opl3sa2(&opl3sa2_state[card].cfg, card); + conf_printf(opl3sa2_state[card].chipset_name, &opl3sa2_state[card].cfg); + attach_opl3sa2_mixer(&opl3sa2_state[card].cfg, card); + attach_opl3sa2_mss(&opl3sa2_state[card].cfg_mss, ports); + + /* ewww =) */ + opl3sa2_state[card].card = card; +#ifdef CONFIG_PM + /* register our power management capabilities */ + opl3sa2_state[card].pmdev = pm_register(PM_ISA_DEV, card, opl3sa2_pm_callback); + if (opl3sa2_state[card].pmdev) + opl3sa2_state[card].pmdev->data = &opl3sa2_state[card]; +#endif /* CONFIG_PM */ + + /* + * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and + * it's supported. + */ + if (ymode != -1) { + if (opl3sa2_state[card].chipset == CHIPSET_OPL3SA2) { + printk(KERN_ERR + PFX "ymode not supported on OPL3-SA2\n"); + } + else { + opl3sa2_set_ymode(&opl3sa2_state[card].cfg, ymode); + } + } + + + /* Set A/D input to Mono loopback if asked to. */ + if (loopback != -1) { + opl3sa2_set_loopback(&opl3sa2_state[card].cfg, loopback); + } + + /* Attach MPU if we've been asked to do so, failure isn't fatal */ + if (opl3sa2_state[card].cfg_mpu.io_base != -1) { + int base = opl3sa2_state[card].cfg_mpu.io_base; + struct resource *ports; + ports = request_region(base, 2, "mpu401"); + if (!ports) + goto out; + if (!probe_mpu401(&opl3sa2_state[card].cfg_mpu, ports)) { + release_region(base, 2); + goto out; + } + if (attach_mpu401(&opl3sa2_state[card].cfg_mpu, THIS_MODULE)) { + printk(KERN_ERR PFX "failed to attach MPU401\n"); + opl3sa2_state[card].cfg_mpu.slots[1] = -1; + } + } + } + +out: + if (isapnp) { + printk(KERN_NOTICE PFX "%d PnP card(s) found.\n", opl3sa2_cards_num); + } + + return 0; +} + + +/* + * Uninstall OPL3-SA2 based card(s). + */ +static void __exit cleanup_opl3sa2(void) +{ + int card; + + for(card = 0; card < opl3sa2_cards_num; card++) { +#ifdef CONFIG_PM + if (opl3sa2_state[card].pmdev) + pm_unregister(opl3sa2_state[card].pmdev); +#endif + if (opl3sa2_state[card].cfg_mpu.slots[1] != -1) { + unload_opl3sa2_mpu(&opl3sa2_state[card].cfg_mpu); + } + unload_opl3sa2_mss(&opl3sa2_state[card].cfg_mss); + unload_opl3sa2(&opl3sa2_state[card].cfg, card); +#ifdef CONFIG_PNP + pnp_unregister_driver(&opl3sa2_driver); +#endif + } +} + +module_init(init_opl3sa2); +module_exit(cleanup_opl3sa2); + +#ifndef MODULE +static int __init setup_opl3sa2(char *str) +{ + /* io, irq, dma, dma2,... */ +#ifdef CONFIG_PNP + int ints[11]; +#else + int ints[9]; +#endif + str = get_options(str, ARRAY_SIZE(ints), ints); + + io = ints[1]; + irq = ints[2]; + dma = ints[3]; + dma2 = ints[4]; + mss_io = ints[5]; + mpu_io = ints[6]; + ymode = ints[7]; + loopback = ints[8]; +#ifdef CONFIG_PNP + isapnp = ints[9]; + multiple = ints[10]; +#endif + return 1; +} + +__setup("opl3sa2=", setup_opl3sa2); +#endif |