Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 2 | * Driver for C-Media's CMI8330 and CMI8329 soundcards. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Copyright (c) by George Talusan <gstalusan@uwaterloo.ca> |
| 4 | * http://www.undergrad.math.uwaterloo.ca/~gstalusa |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | * |
| 20 | */ |
| 21 | |
| 22 | /* |
| 23 | * NOTES |
| 24 | * |
| 25 | * The extended registers contain mixer settings which are largely |
| 26 | * untapped for the time being. |
| 27 | * |
| 28 | * MPU401 and SPDIF are not supported yet. I don't have the hardware |
| 29 | * to aid in coding and testing, so I won't bother. |
| 30 | * |
| 31 | * To quickly load the module, |
| 32 | * |
| 33 | * modprobe -a snd-cmi8330 sbport=0x220 sbirq=5 sbdma8=1 |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 34 | * sbdma16=5 wssport=0x530 wssirq=11 wssdma=0 fmport=0x388 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | * |
| 36 | * This card has two mixers and two PCM devices. I've cheesed it such |
| 37 | * that recording and playback can be done through the same device. |
Ondrej Zary | 74a0094 | 2009-06-27 16:26:35 +0200 | [diff] [blame] | 38 | * The driver "magically" routes the capturing to the AD1848 codec, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | * and playback to the SB16 codec. This allows for full-duplex mode |
| 40 | * to some extent. |
| 41 | * The utilities in alsa-utils are aware of both devices, so passing |
| 42 | * the appropriate parameters to amixer and alsactl will give you |
| 43 | * full control over both mixers. |
| 44 | */ |
| 45 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | #include <linux/init.h> |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 47 | #include <linux/err.h> |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 48 | #include <linux/isa.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | #include <linux/slab.h> |
| 50 | #include <linux/pnp.h> |
| 51 | #include <linux/moduleparam.h> |
| 52 | #include <sound/core.h> |
Krzysztof Helt | 760fc6b8 | 2008-07-31 21:10:47 +0200 | [diff] [blame] | 53 | #include <sound/wss.h> |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 54 | #include <sound/opl3.h> |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 55 | #include <sound/mpu401.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | #include <sound/sb.h> |
| 57 | #include <sound/initval.h> |
| 58 | |
| 59 | /* |
| 60 | */ |
| 61 | /* #define ENABLE_SB_MIXER */ |
| 62 | #define PLAYBACK_ON_SB |
| 63 | |
| 64 | /* |
| 65 | */ |
| 66 | MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>"); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 67 | MODULE_DESCRIPTION("C-Media CMI8330/CMI8329"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | MODULE_LICENSE("GPL"); |
| 69 | MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8330,isapnp:{CMI0001,@@@0001,@X@0001}}}"); |
| 70 | |
| 71 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; |
| 72 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; |
| 73 | static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; |
| 74 | #ifdef CONFIG_PNP |
| 75 | static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; |
| 76 | #endif |
| 77 | static long sbport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; |
| 78 | static int sbirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; |
| 79 | static int sbdma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; |
| 80 | static int sbdma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; |
| 81 | static long wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; |
| 82 | static int wssirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; |
| 83 | static int wssdma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 84 | static long fmport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 85 | static long mpuport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; |
| 86 | static int mpuirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | |
| 88 | module_param_array(index, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 89 | MODULE_PARM_DESC(index, "Index value for CMI8330/CMI8329 soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | module_param_array(id, charp, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 91 | MODULE_PARM_DESC(id, "ID string for CMI8330/CMI8329 soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | module_param_array(enable, bool, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 93 | MODULE_PARM_DESC(enable, "Enable CMI8330/CMI8329 soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | #ifdef CONFIG_PNP |
| 95 | module_param_array(isapnp, bool, NULL, 0444); |
| 96 | MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard."); |
| 97 | #endif |
| 98 | |
| 99 | module_param_array(sbport, long, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 100 | MODULE_PARM_DESC(sbport, "Port # for CMI8330/CMI8329 SB driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | module_param_array(sbirq, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 102 | MODULE_PARM_DESC(sbirq, "IRQ # for CMI8330/CMI8329 SB driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | module_param_array(sbdma8, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 104 | MODULE_PARM_DESC(sbdma8, "DMA8 for CMI8330/CMI8329 SB driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | module_param_array(sbdma16, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 106 | MODULE_PARM_DESC(sbdma16, "DMA16 for CMI8330/CMI8329 SB driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | |
| 108 | module_param_array(wssport, long, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 109 | MODULE_PARM_DESC(wssport, "Port # for CMI8330/CMI8329 WSS driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | module_param_array(wssirq, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 111 | MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330/CMI8329 WSS driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | module_param_array(wssdma, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 113 | MODULE_PARM_DESC(wssdma, "DMA for CMI8330/CMI8329 WSS driver."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 115 | module_param_array(fmport, long, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 116 | MODULE_PARM_DESC(fmport, "FM port # for CMI8330/CMI8329 driver."); |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 117 | module_param_array(mpuport, long, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 118 | MODULE_PARM_DESC(mpuport, "MPU-401 port # for CMI8330/CMI8329 driver."); |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 119 | module_param_array(mpuirq, int, NULL, 0444); |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 120 | MODULE_PARM_DESC(mpuirq, "IRQ # for CMI8330/CMI8329 MPU-401 port."); |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 121 | #ifdef CONFIG_PNP |
Rene Herman | 609d769 | 2007-05-15 11:42:56 +0200 | [diff] [blame] | 122 | static int isa_registered; |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 123 | static int pnp_registered; |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 124 | #endif |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 125 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | #define CMI8330_RMUX3D 16 |
| 127 | #define CMI8330_MUTEMUX 17 |
| 128 | #define CMI8330_OUTPUTVOL 18 |
| 129 | #define CMI8330_MASTVOL 19 |
| 130 | #define CMI8330_LINVOL 20 |
| 131 | #define CMI8330_CDINVOL 21 |
| 132 | #define CMI8330_WAVVOL 22 |
| 133 | #define CMI8330_RECMUX 23 |
| 134 | #define CMI8330_WAVGAIN 24 |
| 135 | #define CMI8330_LINGAIN 25 |
| 136 | #define CMI8330_CDINGAIN 26 |
| 137 | |
| 138 | static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] = |
| 139 | { |
| 140 | 0x40, /* 16 - recording mux (SB-mixer-enabled) */ |
| 141 | #ifdef ENABLE_SB_MIXER |
| 142 | 0x40, /* 17 - mute mux (Mode2) */ |
| 143 | #else |
| 144 | 0x0, /* 17 - mute mux */ |
| 145 | #endif |
| 146 | 0x0, /* 18 - vol */ |
| 147 | 0x0, /* 19 - master volume */ |
| 148 | 0x0, /* 20 - line-in volume */ |
| 149 | 0x0, /* 21 - cd-in volume */ |
| 150 | 0x0, /* 22 - wave volume */ |
| 151 | 0x0, /* 23 - mute/rec mux */ |
| 152 | 0x0, /* 24 - wave rec gain */ |
| 153 | 0x0, /* 25 - line-in rec gain */ |
| 154 | 0x0 /* 26 - cd-in rec gain */ |
| 155 | }; |
| 156 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 157 | typedef int (*snd_pcm_open_callback_t)(struct snd_pcm_substream *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 159 | enum card_type { |
| 160 | CMI8330, |
| 161 | CMI8329 |
| 162 | }; |
| 163 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | struct snd_cmi8330 { |
| 165 | #ifdef CONFIG_PNP |
| 166 | struct pnp_dev *cap; |
| 167 | struct pnp_dev *play; |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 168 | struct pnp_dev *mpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | #endif |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 170 | struct snd_card *card; |
Krzysztof Helt | 241b3ee | 2008-07-31 21:04:37 +0200 | [diff] [blame] | 171 | struct snd_wss *wss; |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 172 | struct snd_sb *sb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 174 | struct snd_pcm *pcm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | struct snd_cmi8330_stream { |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 176 | struct snd_pcm_ops ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | snd_pcm_open_callback_t open; |
| 178 | void *private_data; /* sb or wss */ |
| 179 | } streams[2]; |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 180 | |
| 181 | enum card_type type; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | }; |
| 183 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | #ifdef CONFIG_PNP |
| 185 | |
| 186 | static struct pnp_card_device_id snd_cmi8330_pnpids[] = { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 187 | { .id = "CMI0001", .devs = { { "@X@0001" }, { "@@@0001" }, { "@H@0001" }, { "A@@0001" } } }, |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 188 | { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | { .id = "" } |
| 190 | }; |
| 191 | |
| 192 | MODULE_DEVICE_TABLE(pnp_card, snd_cmi8330_pnpids); |
| 193 | |
| 194 | #endif |
| 195 | |
| 196 | |
Krzysztof Helt | 0c5e3e9 | 2008-07-31 21:06:46 +0200 | [diff] [blame] | 197 | static struct snd_kcontrol_new snd_cmi8330_controls[] __devinitdata = { |
| 198 | WSS_DOUBLE("Master Playback Volume", 0, |
| 199 | CMI8330_MASTVOL, CMI8330_MASTVOL, 4, 0, 15, 0), |
| 200 | WSS_SINGLE("Loud Playback Switch", 0, |
| 201 | CMI8330_MUTEMUX, 6, 1, 1), |
| 202 | WSS_DOUBLE("PCM Playback Switch", 0, |
Krzysztof Helt | 760fc6b8 | 2008-07-31 21:10:47 +0200 | [diff] [blame] | 203 | CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1), |
Krzysztof Helt | 0c5e3e9 | 2008-07-31 21:06:46 +0200 | [diff] [blame] | 204 | WSS_DOUBLE("PCM Playback Volume", 0, |
Krzysztof Helt | 760fc6b8 | 2008-07-31 21:10:47 +0200 | [diff] [blame] | 205 | CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1), |
Krzysztof Helt | 0c5e3e9 | 2008-07-31 21:06:46 +0200 | [diff] [blame] | 206 | WSS_DOUBLE("Line Playback Switch", 0, |
| 207 | CMI8330_MUTEMUX, CMI8330_MUTEMUX, 4, 3, 1, 0), |
| 208 | WSS_DOUBLE("Line Playback Volume", 0, |
| 209 | CMI8330_LINVOL, CMI8330_LINVOL, 4, 0, 15, 0), |
| 210 | WSS_DOUBLE("Line Capture Switch", 0, |
| 211 | CMI8330_RMUX3D, CMI8330_RMUX3D, 2, 1, 1, 0), |
| 212 | WSS_DOUBLE("Line Capture Volume", 0, |
| 213 | CMI8330_LINGAIN, CMI8330_LINGAIN, 4, 0, 15, 0), |
| 214 | WSS_DOUBLE("CD Playback Switch", 0, |
| 215 | CMI8330_MUTEMUX, CMI8330_MUTEMUX, 2, 1, 1, 0), |
| 216 | WSS_DOUBLE("CD Capture Switch", 0, |
| 217 | CMI8330_RMUX3D, CMI8330_RMUX3D, 4, 3, 1, 0), |
| 218 | WSS_DOUBLE("CD Playback Volume", 0, |
| 219 | CMI8330_CDINVOL, CMI8330_CDINVOL, 4, 0, 15, 0), |
| 220 | WSS_DOUBLE("CD Capture Volume", 0, |
| 221 | CMI8330_CDINGAIN, CMI8330_CDINGAIN, 4, 0, 15, 0), |
| 222 | WSS_SINGLE("Mic Playback Switch", 0, |
| 223 | CMI8330_MUTEMUX, 0, 1, 0), |
| 224 | WSS_SINGLE("Mic Playback Volume", 0, |
| 225 | CMI8330_OUTPUTVOL, 0, 7, 0), |
| 226 | WSS_SINGLE("Mic Capture Switch", 0, |
| 227 | CMI8330_RMUX3D, 0, 1, 0), |
| 228 | WSS_SINGLE("Mic Capture Volume", 0, |
| 229 | CMI8330_OUTPUTVOL, 5, 7, 0), |
| 230 | WSS_DOUBLE("Wavetable Playback Switch", 0, |
| 231 | CMI8330_RECMUX, CMI8330_RECMUX, 1, 0, 1, 0), |
| 232 | WSS_DOUBLE("Wavetable Playback Volume", 0, |
| 233 | CMI8330_WAVVOL, CMI8330_WAVVOL, 4, 0, 15, 0), |
| 234 | WSS_DOUBLE("Wavetable Capture Switch", 0, |
| 235 | CMI8330_RECMUX, CMI8330_RECMUX, 5, 4, 1, 0), |
| 236 | WSS_DOUBLE("Wavetable Capture Volume", 0, |
| 237 | CMI8330_WAVGAIN, CMI8330_WAVGAIN, 4, 0, 15, 0), |
| 238 | WSS_SINGLE("3D Control - Switch", 0, |
| 239 | CMI8330_RMUX3D, 5, 1, 1), |
Jaroslav Kysela | d355c82a | 2009-11-03 15:47:25 +0100 | [diff] [blame] | 240 | WSS_SINGLE("Beep Playback Volume", 0, |
Krzysztof Helt | 0c5e3e9 | 2008-07-31 21:06:46 +0200 | [diff] [blame] | 241 | CMI8330_OUTPUTVOL, 3, 3, 0), |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 242 | WSS_DOUBLE("FM Playback Switch", 0, |
| 243 | CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1), |
| 244 | WSS_DOUBLE("FM Playback Volume", 0, |
| 245 | CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1), |
Krzysztof Helt | 0c5e3e9 | 2008-07-31 21:06:46 +0200 | [diff] [blame] | 246 | WSS_SINGLE(SNDRV_CTL_NAME_IEC958("Input ", CAPTURE, SWITCH), 0, |
| 247 | CMI8330_RMUX3D, 7, 1, 1), |
| 248 | WSS_SINGLE(SNDRV_CTL_NAME_IEC958("Input ", PLAYBACK, SWITCH), 0, |
| 249 | CMI8330_MUTEMUX, 7, 1, 1), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | }; |
| 251 | |
| 252 | #ifdef ENABLE_SB_MIXER |
Bjorn Helgaas | 07d58ad | 2006-03-27 01:17:11 -0800 | [diff] [blame] | 253 | static struct sbmix_elem cmi8330_sb_mixers[] __devinitdata = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31), |
| 255 | SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15), |
| 256 | SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15), |
| 257 | SB_DOUBLE("SB PCM Playback Volume", SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31), |
| 258 | SB_DOUBLE("SB Synth Playback Volume", SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31), |
| 259 | SB_DOUBLE("SB CD Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1), |
| 260 | SB_DOUBLE("SB CD Playback Volume", SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31), |
| 261 | SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1), |
| 262 | SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31), |
| 263 | SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1), |
| 264 | SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31), |
Jaroslav Kysela | d355c82a | 2009-11-03 15:47:25 +0100 | [diff] [blame] | 265 | SB_SINGLE("SB Beep Volume", SB_DSP4_SPEAKER_DEV, 6, 3), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3), |
| 267 | SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3), |
| 268 | SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1), |
| 269 | }; |
| 270 | |
Bjorn Helgaas | 07d58ad | 2006-03-27 01:17:11 -0800 | [diff] [blame] | 271 | static unsigned char cmi8330_sb_init_values[][2] __devinitdata = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | { SB_DSP4_MASTER_DEV + 0, 0 }, |
| 273 | { SB_DSP4_MASTER_DEV + 1, 0 }, |
| 274 | { SB_DSP4_PCM_DEV + 0, 0 }, |
| 275 | { SB_DSP4_PCM_DEV + 1, 0 }, |
| 276 | { SB_DSP4_SYNTH_DEV + 0, 0 }, |
| 277 | { SB_DSP4_SYNTH_DEV + 1, 0 }, |
| 278 | { SB_DSP4_INPUT_LEFT, 0 }, |
| 279 | { SB_DSP4_INPUT_RIGHT, 0 }, |
| 280 | { SB_DSP4_OUTPUT_SW, 0 }, |
| 281 | { SB_DSP4_SPEAKER_DEV, 0 }, |
| 282 | }; |
| 283 | |
| 284 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 285 | static int __devinit cmi8330_add_sb_mixers(struct snd_sb *chip) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | { |
| 287 | int idx, err; |
| 288 | unsigned long flags; |
| 289 | |
| 290 | spin_lock_irqsave(&chip->mixer_lock, flags); |
| 291 | snd_sbmixer_write(chip, 0x00, 0x00); /* mixer reset */ |
| 292 | spin_unlock_irqrestore(&chip->mixer_lock, flags); |
| 293 | |
| 294 | /* mute and zero volume channels */ |
| 295 | for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_init_values); idx++) { |
| 296 | spin_lock_irqsave(&chip->mixer_lock, flags); |
| 297 | snd_sbmixer_write(chip, cmi8330_sb_init_values[idx][0], |
| 298 | cmi8330_sb_init_values[idx][1]); |
| 299 | spin_unlock_irqrestore(&chip->mixer_lock, flags); |
| 300 | } |
| 301 | |
| 302 | for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_mixers); idx++) { |
| 303 | if ((err = snd_sbmixer_add_ctl_elem(chip, &cmi8330_sb_mixers[idx])) < 0) |
| 304 | return err; |
| 305 | } |
| 306 | return 0; |
| 307 | } |
| 308 | #endif |
| 309 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 310 | static int __devinit snd_cmi8330_mixer(struct snd_card *card, struct snd_cmi8330 *acard) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | { |
| 312 | unsigned int idx; |
| 313 | int err; |
| 314 | |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 315 | strcpy(card->mixername, (acard->type == CMI8329) ? "CMI8329" : "CMI8330/C3D"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | |
| 317 | for (idx = 0; idx < ARRAY_SIZE(snd_cmi8330_controls); idx++) { |
Krzysztof Helt | 0c5e3e9 | 2008-07-31 21:06:46 +0200 | [diff] [blame] | 318 | err = snd_ctl_add(card, |
| 319 | snd_ctl_new1(&snd_cmi8330_controls[idx], |
| 320 | acard->wss)); |
| 321 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | return err; |
| 323 | } |
| 324 | |
| 325 | #ifdef ENABLE_SB_MIXER |
| 326 | if ((err = cmi8330_add_sb_mixers(acard->sb)) < 0) |
| 327 | return err; |
| 328 | #endif |
| 329 | return 0; |
| 330 | } |
| 331 | |
| 332 | #ifdef CONFIG_PNP |
| 333 | static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard, |
| 334 | struct pnp_card_link *card, |
| 335 | const struct pnp_card_device_id *id) |
| 336 | { |
| 337 | struct pnp_dev *pdev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | int err; |
| 339 | |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 340 | /* CMI8329 has a device with ID A@@0001, CMI8330 does not */ |
| 341 | acard->type = (id->devs[3].id[0]) ? CMI8329 : CMI8330; |
| 342 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | acard->cap = pnp_request_card_device(card, id->devs[0].id, NULL); |
Rene Herman | 109c53f84 | 2007-11-30 17:59:25 +0100 | [diff] [blame] | 344 | if (acard->cap == NULL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | return -EBUSY; |
Rene Herman | 109c53f84 | 2007-11-30 17:59:25 +0100 | [diff] [blame] | 346 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | acard->play = pnp_request_card_device(card, id->devs[1].id, NULL); |
Rene Herman | 109c53f84 | 2007-11-30 17:59:25 +0100 | [diff] [blame] | 348 | if (acard->play == NULL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | return -EBUSY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 351 | acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL); |
Ondrej Zary | c2a30d7 | 2009-06-27 16:17:08 +0200 | [diff] [blame] | 352 | if (acard->mpu == NULL) |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 353 | return -EBUSY; |
| 354 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | pdev = acard->cap; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | err = pnp_activate_dev(pdev); |
| 358 | if (err < 0) { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 359 | snd_printk(KERN_ERR "AD1848 PnP configure failure\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 360 | return -EBUSY; |
| 361 | } |
| 362 | wssport[dev] = pnp_port_start(pdev, 0); |
| 363 | wssdma[dev] = pnp_dma(pdev, 0); |
| 364 | wssirq[dev] = pnp_irq(pdev, 0); |
Ondrej Zary | 0b95916 | 2009-07-06 22:08:04 +0200 | [diff] [blame] | 365 | if (pnp_port_start(pdev, 1)) |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 366 | fmport[dev] = pnp_port_start(pdev, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | |
| 368 | /* allocate SB16 resources */ |
| 369 | pdev = acard->play; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | err = pnp_activate_dev(pdev); |
| 372 | if (err < 0) { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 373 | snd_printk(KERN_ERR "SB16 PnP configure failure\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | return -EBUSY; |
| 375 | } |
| 376 | sbport[dev] = pnp_port_start(pdev, 0); |
| 377 | sbdma8[dev] = pnp_dma(pdev, 0); |
| 378 | sbdma16[dev] = pnp_dma(pdev, 1); |
| 379 | sbirq[dev] = pnp_irq(pdev, 0); |
Ondrej Zary | 0b95916 | 2009-07-06 22:08:04 +0200 | [diff] [blame] | 380 | /* On CMI8239, the OPL3 port might be present in SB16 PnP resources */ |
| 381 | if (fmport[dev] == SNDRV_AUTO_PORT) { |
| 382 | if (pnp_port_start(pdev, 1)) |
| 383 | fmport[dev] = pnp_port_start(pdev, 1); |
| 384 | else |
| 385 | fmport[dev] = 0x388; /* Or hardwired */ |
| 386 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 388 | /* allocate MPU-401 resources */ |
| 389 | pdev = acard->mpu; |
| 390 | |
| 391 | err = pnp_activate_dev(pdev); |
Ondrej Zary | 72b43cf | 2009-07-07 18:09:48 +0200 | [diff] [blame] | 392 | if (err < 0) |
| 393 | snd_printk(KERN_ERR "MPU-401 PnP configure failure: will be disabled\n"); |
| 394 | else { |
| 395 | mpuport[dev] = pnp_port_start(pdev, 0); |
| 396 | mpuirq[dev] = pnp_irq(pdev, 0); |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 397 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | return 0; |
| 399 | } |
| 400 | #endif |
| 401 | |
| 402 | /* |
| 403 | * PCM interface |
| 404 | * |
| 405 | * since we call the different chip interfaces for playback and capture |
| 406 | * directions, we need a trick. |
| 407 | * |
| 408 | * - copy the ops for each direction into a local record. |
| 409 | * - replace the open callback with the new one, which replaces the |
| 410 | * substream->private_data with the corresponding chip instance |
| 411 | * and calls again the original open callback of the chip. |
| 412 | * |
| 413 | */ |
| 414 | |
| 415 | #ifdef PLAYBACK_ON_SB |
| 416 | #define CMI_SB_STREAM SNDRV_PCM_STREAM_PLAYBACK |
| 417 | #define CMI_AD_STREAM SNDRV_PCM_STREAM_CAPTURE |
| 418 | #else |
| 419 | #define CMI_SB_STREAM SNDRV_PCM_STREAM_CAPTURE |
| 420 | #define CMI_AD_STREAM SNDRV_PCM_STREAM_PLAYBACK |
| 421 | #endif |
| 422 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 423 | static int snd_cmi8330_playback_open(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | { |
| 425 | struct snd_cmi8330 *chip = snd_pcm_substream_chip(substream); |
| 426 | |
| 427 | /* replace the private_data and call the original open callback */ |
| 428 | substream->private_data = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].private_data; |
| 429 | return chip->streams[SNDRV_PCM_STREAM_PLAYBACK].open(substream); |
| 430 | } |
| 431 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 432 | static int snd_cmi8330_capture_open(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | { |
| 434 | struct snd_cmi8330 *chip = snd_pcm_substream_chip(substream); |
| 435 | |
| 436 | /* replace the private_data and call the original open callback */ |
| 437 | substream->private_data = chip->streams[SNDRV_PCM_STREAM_CAPTURE].private_data; |
| 438 | return chip->streams[SNDRV_PCM_STREAM_CAPTURE].open(substream); |
| 439 | } |
| 440 | |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 441 | static int __devinit snd_cmi8330_pcm(struct snd_card *card, struct snd_cmi8330 *chip) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | { |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 443 | struct snd_pcm *pcm; |
| 444 | const struct snd_pcm_ops *ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | int err; |
| 446 | static snd_pcm_open_callback_t cmi_open_callbacks[2] = { |
| 447 | snd_cmi8330_playback_open, |
| 448 | snd_cmi8330_capture_open |
| 449 | }; |
| 450 | |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 451 | if ((err = snd_pcm_new(card, (chip->type == CMI8329) ? "CMI8329" : "CMI8330", 0, 1, 1, &pcm)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 452 | return err; |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 453 | strcpy(pcm->name, (chip->type == CMI8329) ? "CMI8329" : "CMI8330"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | pcm->private_data = chip; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | |
| 456 | /* SB16 */ |
| 457 | ops = snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM); |
| 458 | chip->streams[CMI_SB_STREAM].ops = *ops; |
| 459 | chip->streams[CMI_SB_STREAM].open = ops->open; |
| 460 | chip->streams[CMI_SB_STREAM].ops.open = cmi_open_callbacks[CMI_SB_STREAM]; |
| 461 | chip->streams[CMI_SB_STREAM].private_data = chip->sb; |
| 462 | |
| 463 | /* AD1848 */ |
Krzysztof Helt | ead893c | 2008-07-31 21:09:32 +0200 | [diff] [blame] | 464 | ops = snd_wss_get_pcm_ops(CMI_AD_STREAM); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 465 | chip->streams[CMI_AD_STREAM].ops = *ops; |
| 466 | chip->streams[CMI_AD_STREAM].open = ops->open; |
| 467 | chip->streams[CMI_AD_STREAM].ops.open = cmi_open_callbacks[CMI_AD_STREAM]; |
| 468 | chip->streams[CMI_AD_STREAM].private_data = chip->wss; |
| 469 | |
| 470 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &chip->streams[SNDRV_PCM_STREAM_PLAYBACK].ops); |
| 471 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &chip->streams[SNDRV_PCM_STREAM_CAPTURE].ops); |
| 472 | |
| 473 | snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, |
| 474 | snd_dma_isa_data(), |
| 475 | 64*1024, 128*1024); |
| 476 | chip->pcm = pcm; |
| 477 | |
| 478 | return 0; |
| 479 | } |
| 480 | |
| 481 | |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 482 | #ifdef CONFIG_PM |
| 483 | static int snd_cmi8330_suspend(struct snd_card *card) |
| 484 | { |
| 485 | struct snd_cmi8330 *acard = card->private_data; |
| 486 | |
| 487 | snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); |
| 488 | snd_pcm_suspend_all(acard->pcm); |
| 489 | acard->wss->suspend(acard->wss); |
| 490 | snd_sbmixer_suspend(acard->sb); |
| 491 | return 0; |
| 492 | } |
| 493 | |
| 494 | static int snd_cmi8330_resume(struct snd_card *card) |
| 495 | { |
| 496 | struct snd_cmi8330 *acard = card->private_data; |
| 497 | |
| 498 | snd_sbdsp_reset(acard->sb); |
| 499 | snd_sbmixer_suspend(acard->sb); |
| 500 | acard->wss->resume(acard->wss); |
| 501 | snd_power_change_state(card, SNDRV_CTL_POWER_D0); |
| 502 | return 0; |
| 503 | } |
| 504 | #endif |
| 505 | |
| 506 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 507 | /* |
| 508 | */ |
| 509 | |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 510 | #ifdef CONFIG_PNP |
| 511 | #define is_isapnp_selected(dev) isapnp[dev] |
| 512 | #else |
| 513 | #define is_isapnp_selected(dev) 0 |
| 514 | #endif |
| 515 | |
| 516 | #define PFX "cmi8330: " |
| 517 | |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 518 | static int snd_cmi8330_card_new(int dev, struct snd_card **cardp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 519 | { |
Takashi Iwai | e356170 | 2005-11-17 14:41:02 +0100 | [diff] [blame] | 520 | struct snd_card *card; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 521 | struct snd_cmi8330 *acard; |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 522 | int err; |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 523 | |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 524 | err = snd_card_create(index[dev], id[dev], THIS_MODULE, |
| 525 | sizeof(struct snd_cmi8330), &card); |
| 526 | if (err < 0) { |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 527 | snd_printk(KERN_ERR PFX "could not get a new card\n"); |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 528 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 529 | } |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 530 | acard = card->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 531 | acard->card = card; |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 532 | *cardp = card; |
| 533 | return 0; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 534 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 536 | static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) |
| 537 | { |
| 538 | struct snd_cmi8330 *acard; |
| 539 | int i, err; |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 540 | struct snd_opl3 *opl3; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 542 | acard = card->private_data; |
Krzysztof Helt | 760fc6b8 | 2008-07-31 21:10:47 +0200 | [diff] [blame] | 543 | err = snd_wss_create(card, wssport[dev] + 4, -1, |
| 544 | wssirq[dev], |
| 545 | wssdma[dev], -1, |
| 546 | WSS_HW_DETECT, 0, &acard->wss); |
| 547 | if (err < 0) { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 548 | snd_printk(KERN_ERR PFX "AD1848 device busy??\n"); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 549 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 550 | } |
Krzysztof Helt | ece11c9 | 2008-07-31 21:05:44 +0200 | [diff] [blame] | 551 | if (acard->wss->hardware != WSS_HW_CMI8330) { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 552 | snd_printk(KERN_ERR PFX "AD1848 not found during probe\n"); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 553 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | } |
| 555 | |
| 556 | if ((err = snd_sbdsp_create(card, sbport[dev], |
| 557 | sbirq[dev], |
| 558 | snd_sb16dsp_interrupt, |
| 559 | sbdma8[dev], |
| 560 | sbdma16[dev], |
| 561 | SB_HW_AUTO, &acard->sb)) < 0) { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 562 | snd_printk(KERN_ERR PFX "SB16 device busy??\n"); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 563 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 564 | } |
| 565 | if (acard->sb->hardware != SB_HW_16) { |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 566 | snd_printk(KERN_ERR PFX "SB16 not found during probe\n"); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 567 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 568 | } |
| 569 | |
Krzysztof Helt | 760fc6b8 | 2008-07-31 21:10:47 +0200 | [diff] [blame] | 570 | snd_wss_out(acard->wss, CS4231_MISC_INFO, 0x40); /* switch on MODE2 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 571 | for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++) |
Krzysztof Helt | 760fc6b8 | 2008-07-31 21:10:47 +0200 | [diff] [blame] | 572 | snd_wss_out(acard->wss, i, |
| 573 | snd_cmi8330_image[i - CMI8330_RMUX3D]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | |
| 575 | if ((err = snd_cmi8330_mixer(card, acard)) < 0) { |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 576 | snd_printk(KERN_ERR PFX "failed to create mixers\n"); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 577 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | } |
| 579 | |
| 580 | if ((err = snd_cmi8330_pcm(card, acard)) < 0) { |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 581 | snd_printk(KERN_ERR PFX "failed to create pcms\n"); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 582 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 583 | } |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 584 | if (fmport[dev] != SNDRV_AUTO_PORT) { |
| 585 | if (snd_opl3_create(card, |
| 586 | fmport[dev], fmport[dev] + 2, |
| 587 | OPL3_HW_AUTO, 0, &opl3) < 0) { |
| 588 | snd_printk(KERN_ERR PFX |
| 589 | "no OPL device at 0x%lx-0x%lx ?\n", |
| 590 | fmport[dev], fmport[dev] + 2); |
| 591 | } else { |
Krzysztof Helt | 48972cc | 2009-01-21 08:18:16 +0100 | [diff] [blame] | 592 | err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); |
| 593 | if (err < 0) |
| 594 | return err; |
| 595 | } |
| 596 | } |
| 597 | |
Krzysztof Helt | c97dff8 | 2009-01-29 11:48:14 +0100 | [diff] [blame] | 598 | if (mpuport[dev] != SNDRV_AUTO_PORT) { |
| 599 | if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, |
| 600 | mpuport[dev], 0, mpuirq[dev], |
| 601 | IRQF_DISABLED, NULL) < 0) |
| 602 | printk(KERN_ERR PFX "no MPU-401 device at 0x%lx.\n", |
| 603 | mpuport[dev]); |
| 604 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 605 | |
Ondrej Zary | 69eb888 | 2009-07-04 22:25:44 +0200 | [diff] [blame] | 606 | strcpy(card->driver, (acard->type == CMI8329) ? "CMI8329" : "CMI8330/C3D"); |
| 607 | strcpy(card->shortname, (acard->type == CMI8329) ? "C-Media CMI8329" : "C-Media CMI8330/C3D"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 608 | sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d", |
| 609 | card->shortname, |
| 610 | acard->wss->port, |
| 611 | wssirq[dev], |
| 612 | wssdma[dev]); |
| 613 | |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 614 | return snd_card_register(card); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | } |
| 616 | |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 617 | static int __devinit snd_cmi8330_isa_match(struct device *pdev, |
| 618 | unsigned int dev) |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 619 | { |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 620 | if (!enable[dev] || is_isapnp_selected(dev)) |
| 621 | return 0; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 622 | if (wssport[dev] == SNDRV_AUTO_PORT) { |
| 623 | snd_printk(KERN_ERR PFX "specify wssport\n"); |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 624 | return 0; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 625 | } |
| 626 | if (sbport[dev] == SNDRV_AUTO_PORT) { |
| 627 | snd_printk(KERN_ERR PFX "specify sbport\n"); |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 628 | return 0; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 629 | } |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 630 | return 1; |
| 631 | } |
| 632 | |
| 633 | static int __devinit snd_cmi8330_isa_probe(struct device *pdev, |
| 634 | unsigned int dev) |
| 635 | { |
| 636 | struct snd_card *card; |
| 637 | int err; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 638 | |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 639 | err = snd_cmi8330_card_new(dev, &card); |
| 640 | if (err < 0) |
| 641 | return err; |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 642 | snd_card_set_dev(card, pdev); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 643 | if ((err = snd_cmi8330_probe(card, dev)) < 0) { |
| 644 | snd_card_free(card); |
| 645 | return err; |
| 646 | } |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 647 | dev_set_drvdata(pdev, card); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 648 | return 0; |
| 649 | } |
| 650 | |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 651 | static int __devexit snd_cmi8330_isa_remove(struct device *devptr, |
| 652 | unsigned int dev) |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 653 | { |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 654 | snd_card_free(dev_get_drvdata(devptr)); |
| 655 | dev_set_drvdata(devptr, NULL); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 656 | return 0; |
| 657 | } |
| 658 | |
| 659 | #ifdef CONFIG_PM |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 660 | static int snd_cmi8330_isa_suspend(struct device *dev, unsigned int n, |
| 661 | pm_message_t state) |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 662 | { |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 663 | return snd_cmi8330_suspend(dev_get_drvdata(dev)); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 664 | } |
| 665 | |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 666 | static int snd_cmi8330_isa_resume(struct device *dev, unsigned int n) |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 667 | { |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 668 | return snd_cmi8330_resume(dev_get_drvdata(dev)); |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 669 | } |
| 670 | #endif |
| 671 | |
Rene Herman | 83c51c0 | 2007-03-20 11:33:46 +0100 | [diff] [blame] | 672 | #define DEV_NAME "cmi8330" |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 673 | |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 674 | static struct isa_driver snd_cmi8330_driver = { |
| 675 | .match = snd_cmi8330_isa_match, |
| 676 | .probe = snd_cmi8330_isa_probe, |
| 677 | .remove = __devexit_p(snd_cmi8330_isa_remove), |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 678 | #ifdef CONFIG_PM |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 679 | .suspend = snd_cmi8330_isa_suspend, |
| 680 | .resume = snd_cmi8330_isa_resume, |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 681 | #endif |
| 682 | .driver = { |
Rene Herman | 83c51c0 | 2007-03-20 11:33:46 +0100 | [diff] [blame] | 683 | .name = DEV_NAME |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 684 | }, |
| 685 | }; |
| 686 | |
| 687 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 688 | #ifdef CONFIG_PNP |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 689 | static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *pcard, |
| 690 | const struct pnp_card_device_id *pid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 691 | { |
| 692 | static int dev; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 693 | struct snd_card *card; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 694 | int res; |
| 695 | |
| 696 | for ( ; dev < SNDRV_CARDS; dev++) { |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 697 | if (enable[dev] && isapnp[dev]) |
| 698 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 699 | } |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 700 | if (dev >= SNDRV_CARDS) |
| 701 | return -ENODEV; |
| 702 | |
Takashi Iwai | c95eadd | 2008-12-28 16:43:35 +0100 | [diff] [blame] | 703 | res = snd_cmi8330_card_new(dev, &card); |
| 704 | if (res < 0) |
| 705 | return res; |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 706 | if ((res = snd_cmi8330_pnp(dev, card->private_data, pcard, pid)) < 0) { |
| 707 | snd_printk(KERN_ERR PFX "PnP detection failed\n"); |
| 708 | snd_card_free(card); |
| 709 | return res; |
| 710 | } |
| 711 | snd_card_set_dev(card, &pcard->card->dev); |
| 712 | if ((res = snd_cmi8330_probe(card, dev)) < 0) { |
| 713 | snd_card_free(card); |
| 714 | return res; |
| 715 | } |
| 716 | pnp_set_card_drvdata(pcard, card); |
| 717 | dev++; |
| 718 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 719 | } |
| 720 | |
| 721 | static void __devexit snd_cmi8330_pnp_remove(struct pnp_card_link * pcard) |
| 722 | { |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 723 | snd_card_free(pnp_get_card_drvdata(pcard)); |
| 724 | pnp_set_card_drvdata(pcard, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 725 | } |
| 726 | |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 727 | #ifdef CONFIG_PM |
| 728 | static int snd_cmi8330_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) |
| 729 | { |
| 730 | return snd_cmi8330_suspend(pnp_get_card_drvdata(pcard)); |
| 731 | } |
| 732 | |
| 733 | static int snd_cmi8330_pnp_resume(struct pnp_card_link *pcard) |
| 734 | { |
| 735 | return snd_cmi8330_resume(pnp_get_card_drvdata(pcard)); |
| 736 | } |
| 737 | #endif |
| 738 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 739 | static struct pnp_card_driver cmi8330_pnpc_driver = { |
| 740 | .flags = PNP_DRIVER_RES_DISABLE, |
| 741 | .name = "cmi8330", |
| 742 | .id_table = snd_cmi8330_pnpids, |
| 743 | .probe = snd_cmi8330_pnp_detect, |
| 744 | .remove = __devexit_p(snd_cmi8330_pnp_remove), |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 745 | #ifdef CONFIG_PM |
| 746 | .suspend = snd_cmi8330_pnp_suspend, |
| 747 | .resume = snd_cmi8330_pnp_resume, |
| 748 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 749 | }; |
| 750 | #endif /* CONFIG_PNP */ |
| 751 | |
| 752 | static int __init alsa_card_cmi8330_init(void) |
| 753 | { |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 754 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 755 | |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 756 | err = isa_register_driver(&snd_cmi8330_driver, SNDRV_CARDS); |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 757 | #ifdef CONFIG_PNP |
Rene Herman | 609d769 | 2007-05-15 11:42:56 +0200 | [diff] [blame] | 758 | if (!err) |
| 759 | isa_registered = 1; |
| 760 | |
Takashi Iwai | acdcbc1 | 2005-11-17 17:11:35 +0100 | [diff] [blame] | 761 | err = pnp_register_card_driver(&cmi8330_pnpc_driver); |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 762 | if (!err) |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 763 | pnp_registered = 1; |
Rene Herman | 609d769 | 2007-05-15 11:42:56 +0200 | [diff] [blame] | 764 | |
| 765 | if (isa_registered) |
| 766 | err = 0; |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 767 | #endif |
Rene Herman | 609d769 | 2007-05-15 11:42:56 +0200 | [diff] [blame] | 768 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 769 | } |
| 770 | |
| 771 | static void __exit alsa_card_cmi8330_exit(void) |
| 772 | { |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 773 | #ifdef CONFIG_PNP |
| 774 | if (pnp_registered) |
| 775 | pnp_unregister_card_driver(&cmi8330_pnpc_driver); |
Rene Herman | 609d769 | 2007-05-15 11:42:56 +0200 | [diff] [blame] | 776 | |
| 777 | if (isa_registered) |
Takashi Iwai | 5e24c1c | 2007-02-22 12:50:54 +0100 | [diff] [blame] | 778 | #endif |
Rene Herman | 609d769 | 2007-05-15 11:42:56 +0200 | [diff] [blame] | 779 | isa_unregister_driver(&snd_cmi8330_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 780 | } |
| 781 | |
| 782 | module_init(alsa_card_cmi8330_init) |
| 783 | module_exit(alsa_card_cmi8330_exit) |