| /* | |
| * sound/oss/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/pnp.h> | |
| #include <linux/init.h> | |
| #include <linux/module.h> | |
| #include <linux/delay.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 | |
| 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(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; | |
| } | |
| } | |
| } | |
| 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 appropriately */ | |
| 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 */ | |
| /* | |
| * 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; | |
| /* | |
| * 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++) { | |
| 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 |