mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 13:36:41 +07:00
45029c3207
This change removes the old, deprecated interface from the opl3sa2 driver, including the pm_{,un}register() calls, the local storage of the pmdev object and the reference to the old header files. This change is done to assist in eradicating the users of the legacy interface so as to help facilitate the removal of the interface itself. Signed-off-by: Patrick Mochel <mochel@linux.intel.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
1022 lines
27 KiB
C
1022 lines
27 KiB
C
/*
|
|
* 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 "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 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 */
|
|
|
|
/*
|
|
* 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
|