]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Driver for generic CS4232/CS4235/CS4236/CS4236B/CS4237B/CS4238B/CS4239 chips | |
c1017a4c | 3 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
1da177e4 LT |
4 | * |
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 | #include <sound/driver.h> | |
23 | #include <linux/init.h> | |
6bba41ac | 24 | #include <linux/err.h> |
5e24c1c1 | 25 | #include <linux/isa.h> |
1da177e4 LT |
26 | #include <linux/slab.h> |
27 | #include <linux/pnp.h> | |
28 | #include <linux/moduleparam.h> | |
29 | #include <sound/core.h> | |
30 | #include <sound/cs4231.h> | |
31 | #include <sound/mpu401.h> | |
32 | #include <sound/opl3.h> | |
33 | #include <sound/initval.h> | |
34 | ||
c1017a4c | 35 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); |
1da177e4 LT |
36 | MODULE_LICENSE("GPL"); |
37 | #ifdef CS4232 | |
38 | MODULE_DESCRIPTION("Cirrus Logic CS4232"); | |
39 | MODULE_SUPPORTED_DEVICE("{{Turtle Beach,TBS-2000}," | |
40 | "{Turtle Beach,Tropez Plus}," | |
41 | "{SIC CrystalWave 32}," | |
42 | "{Hewlett Packard,Omnibook 5500}," | |
43 | "{TerraTec,Maestro 32/96}," | |
44 | "{Philips,PCA70PS}}"); | |
45 | #else | |
46 | MODULE_DESCRIPTION("Cirrus Logic CS4235-9"); | |
47 | MODULE_SUPPORTED_DEVICE("{{Crystal Semiconductors,CS4235}," | |
48 | "{Crystal Semiconductors,CS4236}," | |
49 | "{Crystal Semiconductors,CS4237}," | |
50 | "{Crystal Semiconductors,CS4238}," | |
51 | "{Crystal Semiconductors,CS4239}," | |
52 | "{Acer,AW37}," | |
53 | "{Acer,AW35/Pro}," | |
54 | "{Crystal,3D}," | |
55 | "{Crystal Computer,TidalWave128}," | |
56 | "{Dell,Optiplex GX1}," | |
57 | "{Dell,Workstation 400 sound}," | |
58 | "{EliteGroup,P5TX-LA sound}," | |
59 | "{Gallant,SC-70P}," | |
60 | "{Gateway,E1000 Onboard CS4236B}," | |
61 | "{Genius,Sound Maker 3DJ}," | |
62 | "{Hewlett Packard,HP6330 sound}," | |
63 | "{IBM,PC 300PL sound}," | |
64 | "{IBM,Aptiva 2137 E24}," | |
65 | "{IBM,IntelliStation M Pro}," | |
66 | "{Intel,Marlin Spike Mobo CS4235}," | |
67 | "{Intel PR440FX Onboard}," | |
68 | "{Guillemot,MaxiSound 16 PnP}," | |
69 | "{NewClear,3D}," | |
70 | "{TerraTec,AudioSystem EWS64L/XL}," | |
71 | "{Typhoon Soundsystem,CS4236B}," | |
72 | "{Turtle Beach,Malibu}," | |
73 | "{Unknown,Digital PC 5000 Onboard}}"); | |
74 | #endif | |
75 | ||
76 | #ifdef CS4232 | |
77 | #define IDENT "CS4232" | |
83c51c0a | 78 | #define DEV_NAME "cs4232" |
1da177e4 LT |
79 | #else |
80 | #define IDENT "CS4236+" | |
83c51c0a | 81 | #define DEV_NAME "cs4236" |
1da177e4 LT |
82 | #endif |
83 | ||
84 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ | |
85 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ | |
86 | static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */ | |
87 | #ifdef CONFIG_PNP | |
88 | static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; | |
89 | #endif | |
90 | static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ | |
91 | static long cport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ | |
92 | static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;/* PnP setup */ | |
93 | static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ | |
94 | static long sb_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ | |
95 | static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,11,12,15 */ | |
96 | static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 9,11,12,15 */ | |
97 | static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */ | |
98 | static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */ | |
99 | ||
100 | module_param_array(index, int, NULL, 0444); | |
101 | MODULE_PARM_DESC(index, "Index value for " IDENT " soundcard."); | |
102 | module_param_array(id, charp, NULL, 0444); | |
103 | MODULE_PARM_DESC(id, "ID string for " IDENT " soundcard."); | |
104 | module_param_array(enable, bool, NULL, 0444); | |
105 | MODULE_PARM_DESC(enable, "Enable " IDENT " soundcard."); | |
106 | #ifdef CONFIG_PNP | |
107 | module_param_array(isapnp, bool, NULL, 0444); | |
108 | MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard."); | |
109 | #endif | |
110 | module_param_array(port, long, NULL, 0444); | |
111 | MODULE_PARM_DESC(port, "Port # for " IDENT " driver."); | |
112 | module_param_array(cport, long, NULL, 0444); | |
113 | MODULE_PARM_DESC(cport, "Control port # for " IDENT " driver."); | |
114 | module_param_array(mpu_port, long, NULL, 0444); | |
115 | MODULE_PARM_DESC(mpu_port, "MPU-401 port # for " IDENT " driver."); | |
116 | module_param_array(fm_port, long, NULL, 0444); | |
117 | MODULE_PARM_DESC(fm_port, "FM port # for " IDENT " driver."); | |
118 | module_param_array(sb_port, long, NULL, 0444); | |
119 | MODULE_PARM_DESC(sb_port, "SB port # for " IDENT " driver (optional)."); | |
120 | module_param_array(irq, int, NULL, 0444); | |
121 | MODULE_PARM_DESC(irq, "IRQ # for " IDENT " driver."); | |
122 | module_param_array(mpu_irq, int, NULL, 0444); | |
123 | MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for " IDENT " driver."); | |
124 | module_param_array(dma1, int, NULL, 0444); | |
125 | MODULE_PARM_DESC(dma1, "DMA1 # for " IDENT " driver."); | |
126 | module_param_array(dma2, int, NULL, 0444); | |
127 | MODULE_PARM_DESC(dma2, "DMA2 # for " IDENT " driver."); | |
128 | ||
59b1b34f | 129 | #ifdef CONFIG_PNP |
609d7694 | 130 | static int isa_registered; |
f7a9275d CL |
131 | static int pnpc_registered; |
132 | #ifdef CS4232 | |
133 | static int pnp_registered; | |
134 | #endif | |
59b1b34f | 135 | #endif /* CONFIG_PNP */ |
f7a9275d | 136 | |
1da177e4 | 137 | struct snd_card_cs4236 { |
6bba41ac | 138 | struct snd_cs4231 *chip; |
1da177e4 LT |
139 | struct resource *res_sb_port; |
140 | #ifdef CONFIG_PNP | |
141 | struct pnp_dev *wss; | |
142 | struct pnp_dev *ctrl; | |
143 | struct pnp_dev *mpu; | |
144 | #endif | |
145 | }; | |
146 | ||
1da177e4 LT |
147 | #ifdef CONFIG_PNP |
148 | ||
a9824c86 TI |
149 | #ifdef CS4232 |
150 | /* | |
151 | * PNP BIOS | |
152 | */ | |
153 | static const struct pnp_device_id snd_cs4232_pnpbiosids[] = { | |
154 | { .id = "CSC0100" }, | |
155 | { .id = "CSC0000" }, | |
156 | /* Guillemot Turtlebeach something appears to be cs4232 compatible | |
157 | * (untested) */ | |
158 | { .id = "GIM0100" }, | |
159 | { .id = "" } | |
160 | }; | |
161 | MODULE_DEVICE_TABLE(pnp, snd_cs4232_pnpbiosids); | |
162 | #endif /* CS4232 */ | |
1da177e4 LT |
163 | |
164 | #ifdef CS4232 | |
6bba41ac | 165 | #define CS423X_ISAPNP_DRIVER "cs4232_isapnp" |
1da177e4 LT |
166 | static struct pnp_card_device_id snd_cs423x_pnpids[] = { |
167 | /* Philips PCA70PS */ | |
168 | { .id = "CSC0d32", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } }, | |
169 | /* TerraTec Maestro 32/96 (CS4232) */ | |
170 | { .id = "CSC1a32", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
171 | /* HP Omnibook 5500 onboard */ | |
172 | { .id = "CSC4232", .devs = { { "CSC0000" }, { "CSC0002" }, { "CSC0003" } } }, | |
173 | /* Unnamed CS4236 card (Made in Taiwan) */ | |
174 | { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
175 | /* Turtle Beach TBS-2000 (CS4232) */ | |
176 | { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSCb006" } } }, | |
177 | /* Turtle Beach Tropez Plus (CS4232) */ | |
178 | { .id = "CSC7632", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } }, | |
179 | /* SIC CrystalWave 32 (CS4232) */ | |
180 | { .id = "CSCf032", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
50f794c8 LS |
181 | /* Netfinity 3000 on-board soundcard */ |
182 | { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC010f" } } }, | |
1da177e4 LT |
183 | /* --- */ |
184 | { .id = "" } /* end */ | |
185 | }; | |
186 | #else /* CS4236 */ | |
6bba41ac | 187 | #define CS423X_ISAPNP_DRIVER "cs4236_isapnp" |
1da177e4 LT |
188 | static struct pnp_card_device_id snd_cs423x_pnpids[] = { |
189 | /* Intel Marlin Spike Motherboard - CS4235 */ | |
190 | { .id = "CSC0225", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
191 | /* Intel Marlin Spike Motherboard (#2) - CS4235 */ | |
192 | { .id = "CSC0225", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } }, | |
193 | /* Unknown Intel mainboard - CS4235 */ | |
194 | { .id = "CSC0225", .devs = { { "CSC0100" }, { "CSC0110" } } }, | |
195 | /* Genius Sound Maker 3DJ - CS4237B */ | |
196 | { .id = "CSC0437", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
197 | /* Digital PC 5000 Onboard - CS4236B */ | |
198 | { .id = "CSC0735", .devs = { { "CSC0000" }, { "CSC0010" } } }, | |
199 | /* some uknown CS4236B */ | |
200 | { .id = "CSC0b35", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
201 | /* Intel PR440FX Onboard sound */ | |
202 | { .id = "CSC0b36", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
203 | /* CS4235 on mainboard without MPU */ | |
204 | { .id = "CSC1425", .devs = { { "CSC0100" }, { "CSC0110" } } }, | |
205 | /* Gateway E1000 Onboard CS4236B */ | |
206 | { .id = "CSC1335", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
207 | /* HP 6330 Onboard sound */ | |
208 | { .id = "CSC1525", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } }, | |
209 | /* Crystal Computer TidalWave128 */ | |
210 | { .id = "CSC1e37", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
211 | /* ACER AW37 - CS4235 */ | |
212 | { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
213 | /* build-in soundcard in EliteGroup P5TX-LA motherboard - CS4237B */ | |
214 | { .id = "CSC4237", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
215 | /* Crystal 3D - CS4237B */ | |
216 | { .id = "CSC4336", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
217 | /* Typhoon Soundsystem PnP - CS4236B */ | |
218 | { .id = "CSC4536", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
219 | /* Crystal CX4235-XQ3 EP - CS4235 */ | |
220 | { .id = "CSC4625", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } }, | |
221 | /* Crystal Semiconductors CS4237B */ | |
222 | { .id = "CSC4637", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
223 | /* NewClear 3D - CX4237B-XQ3 */ | |
224 | { .id = "CSC4837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
225 | /* Dell Optiplex GX1 - CS4236B */ | |
226 | { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
227 | /* Dell P410 motherboard - CS4236B */ | |
228 | { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" } } }, | |
229 | /* Dell Workstation 400 Onboard - CS4236B */ | |
230 | { .id = "CSC6836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
231 | /* Turtle Beach Malibu - CS4237B */ | |
232 | { .id = "CSC7537", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
233 | /* CS4235 - onboard */ | |
234 | { .id = "CSC8025", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } }, | |
235 | /* IBM Aptiva 2137 E24 Onboard - CS4237B */ | |
236 | { .id = "CSC8037", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
237 | /* IBM IntelliStation M Pro motherboard */ | |
238 | { .id = "CSCc835", .devs = { { "CSC0000" }, { "CSC0010" } } }, | |
239 | /* Guillemot MaxiSound 16 PnP - CS4236B */ | |
240 | { .id = "CSC9836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
241 | /* Gallant SC-70P */ | |
242 | { .id = "CSC9837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
243 | /* TerraTec AudioSystem EWS64XL - CS4236B */ | |
244 | { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" }, { "CSCa803" } } }, | |
245 | /* TerraTec AudioSystem EWS64XL - CS4236B */ | |
246 | { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" } } }, | |
247 | /* ACER AW37/Pro - CS4235 */ | |
248 | { .id = "CSCd925", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
249 | /* ACER AW35/Pro - CS4237B */ | |
250 | { .id = "CSCd937", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
251 | /* CS4235 without MPU401 */ | |
252 | { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" } } }, | |
253 | /* Unknown SiS530 - CS4235 */ | |
254 | { .id = "CSC4825", .devs = { { "CSC0100" }, { "CSC0110" } } }, | |
255 | /* IBM IntelliStation M Pro 6898 11U - CS4236B */ | |
256 | { .id = "CSCe835", .devs = { { "CSC0000" }, { "CSC0010" } } }, | |
257 | /* IBM PC 300PL Onboard - CS4236B */ | |
258 | { .id = "CSCe836", .devs = { { "CSC0000" }, { "CSC0010" } } }, | |
259 | /* Some noname CS4236 based card */ | |
260 | { .id = "CSCe936", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
261 | /* CS4236B */ | |
262 | { .id = "CSCf235", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
263 | /* CS4236B */ | |
264 | { .id = "CSCf238", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, | |
265 | /* --- */ | |
266 | { .id = "" } /* end */ | |
267 | }; | |
268 | #endif | |
269 | ||
270 | MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids); | |
271 | ||
a9824c86 TI |
272 | /* WSS initialization */ |
273 | static int __devinit snd_cs423x_pnp_init_wss(int dev, struct pnp_dev *pdev, | |
274 | struct pnp_resource_table *cfg) | |
1da177e4 | 275 | { |
1da177e4 LT |
276 | int err; |
277 | ||
1da177e4 LT |
278 | pnp_init_resource_table(cfg); |
279 | if (port[dev] != SNDRV_AUTO_PORT) | |
280 | pnp_resource_change(&cfg->port_resource[0], port[dev], 4); | |
281 | if (fm_port[dev] != SNDRV_AUTO_PORT && fm_port[dev] > 0) | |
282 | pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4); | |
283 | if (sb_port[dev] != SNDRV_AUTO_PORT) | |
284 | pnp_resource_change(&cfg->port_resource[2], sb_port[dev], 16); | |
285 | if (irq[dev] != SNDRV_AUTO_IRQ) | |
286 | pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1); | |
287 | if (dma1[dev] != SNDRV_AUTO_DMA) | |
288 | pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1); | |
289 | if (dma2[dev] != SNDRV_AUTO_DMA) | |
290 | pnp_resource_change(&cfg->dma_resource[1], dma2[dev] < 0 ? 4 : dma2[dev], 1); | |
291 | err = pnp_manual_config_dev(pdev, cfg, 0); | |
292 | if (err < 0) | |
293 | snd_printk(KERN_ERR IDENT " WSS PnP manual resources are invalid, using auto config\n"); | |
294 | err = pnp_activate_dev(pdev); | |
295 | if (err < 0) { | |
1da177e4 LT |
296 | printk(KERN_ERR IDENT " WSS PnP configure failed for WSS (out of resources?)\n"); |
297 | return -EBUSY; | |
298 | } | |
299 | port[dev] = pnp_port_start(pdev, 0); | |
300 | if (fm_port[dev] > 0) | |
301 | fm_port[dev] = pnp_port_start(pdev, 1); | |
302 | sb_port[dev] = pnp_port_start(pdev, 2); | |
303 | irq[dev] = pnp_irq(pdev, 0); | |
304 | dma1[dev] = pnp_dma(pdev, 0); | |
305 | dma2[dev] = pnp_dma(pdev, 1) == 4 ? -1 : (int)pnp_dma(pdev, 1); | |
306 | snd_printdd("isapnp WSS: wss port=0x%lx, fm port=0x%lx, sb port=0x%lx\n", | |
307 | port[dev], fm_port[dev], sb_port[dev]); | |
308 | snd_printdd("isapnp WSS: irq=%i, dma1=%i, dma2=%i\n", | |
309 | irq[dev], dma1[dev], dma2[dev]); | |
a9824c86 TI |
310 | return 0; |
311 | } | |
312 | ||
313 | /* CTRL initialization */ | |
314 | static int __devinit snd_cs423x_pnp_init_ctrl(int dev, struct pnp_dev *pdev, | |
315 | struct pnp_resource_table *cfg) | |
316 | { | |
317 | int err; | |
318 | ||
319 | pnp_init_resource_table(cfg); | |
320 | if (cport[dev] != SNDRV_AUTO_PORT) | |
321 | pnp_resource_change(&cfg->port_resource[0], cport[dev], 8); | |
322 | err = pnp_manual_config_dev(pdev, cfg, 0); | |
323 | if (err < 0) | |
324 | snd_printk(KERN_ERR IDENT " CTRL PnP manual resources are invalid, using auto config\n"); | |
325 | err = pnp_activate_dev(pdev); | |
326 | if (err < 0) { | |
327 | printk(KERN_ERR IDENT " CTRL PnP configure failed for WSS (out of resources?)\n"); | |
328 | return -EBUSY; | |
329 | } | |
330 | cport[dev] = pnp_port_start(pdev, 0); | |
331 | snd_printdd("isapnp CTRL: control port=0x%lx\n", cport[dev]); | |
332 | return 0; | |
333 | } | |
334 | ||
335 | /* MPU initialization */ | |
336 | static int __devinit snd_cs423x_pnp_init_mpu(int dev, struct pnp_dev *pdev, | |
337 | struct pnp_resource_table *cfg) | |
338 | { | |
339 | int err; | |
340 | ||
341 | pnp_init_resource_table(cfg); | |
342 | if (mpu_port[dev] != SNDRV_AUTO_PORT) | |
343 | pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2); | |
344 | if (mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] >= 0) | |
345 | pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1); | |
346 | err = pnp_manual_config_dev(pdev, cfg, 0); | |
347 | if (err < 0) | |
348 | snd_printk(KERN_ERR IDENT " MPU401 PnP manual resources are invalid, using auto config\n"); | |
349 | err = pnp_activate_dev(pdev); | |
350 | if (err < 0) { | |
351 | printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n"); | |
352 | mpu_port[dev] = SNDRV_AUTO_PORT; | |
353 | mpu_irq[dev] = SNDRV_AUTO_IRQ; | |
354 | } else { | |
355 | mpu_port[dev] = pnp_port_start(pdev, 0); | |
356 | if (mpu_irq[dev] >= 0 && | |
357 | pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) { | |
358 | mpu_irq[dev] = pnp_irq(pdev, 0); | |
359 | } else { | |
360 | mpu_irq[dev] = -1; /* disable interrupt */ | |
361 | } | |
362 | } | |
363 | snd_printdd("isapnp MPU: port=0x%lx, irq=%i\n", mpu_port[dev], mpu_irq[dev]); | |
364 | return 0; | |
365 | } | |
366 | ||
367 | #ifdef CS4232 | |
368 | static int __devinit snd_card_cs4232_pnp(int dev, struct snd_card_cs4236 *acard, | |
369 | struct pnp_dev *pdev) | |
370 | { | |
371 | struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); | |
372 | ||
373 | if (!cfg) | |
374 | return -ENOMEM; | |
375 | if (snd_cs423x_pnp_init_wss(dev, acard->wss, cfg) < 0) { | |
376 | kfree(cfg); | |
377 | return -EBUSY; | |
378 | } | |
379 | kfree(cfg); | |
380 | cport[dev] = -1; | |
381 | return 0; | |
382 | } | |
383 | #endif | |
384 | ||
385 | static int __devinit snd_card_cs423x_pnpc(int dev, struct snd_card_cs4236 *acard, | |
386 | struct pnp_card_link *card, | |
387 | const struct pnp_card_device_id *id) | |
388 | { | |
389 | struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); | |
390 | ||
391 | if (!cfg) | |
392 | return -ENOMEM; | |
393 | ||
394 | acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL); | |
395 | if (acard->wss == NULL) | |
396 | goto error; | |
397 | acard->ctrl = pnp_request_card_device(card, id->devs[1].id, NULL); | |
398 | if (acard->ctrl == NULL) | |
399 | goto error; | |
400 | if (id->devs[2].id[0]) { | |
401 | acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL); | |
402 | if (acard->mpu == NULL) | |
403 | goto error; | |
404 | } | |
405 | ||
406 | /* WSS initialization */ | |
407 | if (snd_cs423x_pnp_init_wss(dev, acard->wss, cfg) < 0) | |
408 | goto error; | |
409 | ||
1da177e4 LT |
410 | /* CTRL initialization */ |
411 | if (acard->ctrl && cport[dev] > 0) { | |
a9824c86 TI |
412 | if (snd_cs423x_pnp_init_ctrl(dev, acard->ctrl, cfg) < 0) |
413 | goto error; | |
1da177e4 LT |
414 | } |
415 | /* MPU initialization */ | |
416 | if (acard->mpu && mpu_port[dev] > 0) { | |
6f595cff | 417 | if (snd_cs423x_pnp_init_mpu(dev, acard->mpu, cfg) < 0) |
a9824c86 | 418 | goto error; |
1da177e4 LT |
419 | } |
420 | kfree(cfg); | |
421 | return 0; | |
a9824c86 TI |
422 | |
423 | error: | |
424 | kfree(cfg); | |
425 | return -EBUSY; | |
1da177e4 LT |
426 | } |
427 | #endif /* CONFIG_PNP */ | |
428 | ||
43bcd973 TI |
429 | #ifdef CONFIG_PNP |
430 | #define is_isapnp_selected(dev) isapnp[dev] | |
431 | #else | |
432 | #define is_isapnp_selected(dev) 0 | |
433 | #endif | |
434 | ||
6bba41ac TI |
435 | static void snd_card_cs4236_free(struct snd_card *card) |
436 | { | |
437 | struct snd_card_cs4236 *acard = card->private_data; | |
438 | ||
439 | release_and_free_resource(acard->res_sb_port); | |
440 | } | |
441 | ||
442 | static struct snd_card *snd_cs423x_card_new(int dev) | |
1da177e4 | 443 | { |
ba2375a4 | 444 | struct snd_card *card; |
1da177e4 | 445 | |
1da177e4 LT |
446 | card = snd_card_new(index[dev], id[dev], THIS_MODULE, |
447 | sizeof(struct snd_card_cs4236)); | |
448 | if (card == NULL) | |
6bba41ac | 449 | return NULL; |
1da177e4 | 450 | card->private_free = snd_card_cs4236_free; |
6bba41ac TI |
451 | return card; |
452 | } | |
453 | ||
454 | static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) | |
455 | { | |
456 | struct snd_card_cs4236 *acard; | |
457 | struct snd_pcm *pcm; | |
458 | struct snd_cs4231 *chip; | |
459 | struct snd_opl3 *opl3; | |
460 | int err; | |
461 | ||
462 | acard = card->private_data; | |
1da177e4 LT |
463 | if (sb_port[dev] > 0 && sb_port[dev] != SNDRV_AUTO_PORT) |
464 | if ((acard->res_sb_port = request_region(sb_port[dev], 16, IDENT " SB")) == NULL) { | |
465 | printk(KERN_ERR IDENT ": unable to register SB port at 0x%lx\n", sb_port[dev]); | |
6bba41ac | 466 | return -EBUSY; |
1da177e4 LT |
467 | } |
468 | ||
469 | #ifdef CS4232 | |
470 | if ((err = snd_cs4231_create(card, | |
471 | port[dev], | |
472 | cport[dev], | |
473 | irq[dev], | |
474 | dma1[dev], | |
475 | dma2[dev], | |
476 | CS4231_HW_DETECT, | |
477 | 0, | |
43bcd973 | 478 | &chip)) < 0) |
6bba41ac TI |
479 | return err; |
480 | acard->chip = chip; | |
43bcd973 TI |
481 | |
482 | if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) | |
6bba41ac | 483 | return err; |
43bcd973 TI |
484 | |
485 | if ((err = snd_cs4231_mixer(chip)) < 0) | |
6bba41ac | 486 | return err; |
1da177e4 LT |
487 | |
488 | #else /* CS4236 */ | |
489 | if ((err = snd_cs4236_create(card, | |
490 | port[dev], | |
491 | cport[dev], | |
492 | irq[dev], | |
493 | dma1[dev], | |
494 | dma2[dev], | |
495 | CS4231_HW_DETECT, | |
496 | 0, | |
43bcd973 | 497 | &chip)) < 0) |
6bba41ac TI |
498 | return err; |
499 | acard->chip = chip; | |
43bcd973 TI |
500 | |
501 | if ((err = snd_cs4236_pcm(chip, 0, &pcm)) < 0) | |
6bba41ac | 502 | return err; |
43bcd973 TI |
503 | |
504 | if ((err = snd_cs4236_mixer(chip)) < 0) | |
6bba41ac | 505 | return err; |
1da177e4 LT |
506 | #endif |
507 | strcpy(card->driver, pcm->name); | |
508 | strcpy(card->shortname, pcm->name); | |
509 | sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i", | |
510 | pcm->name, | |
511 | chip->port, | |
512 | irq[dev], | |
513 | dma1[dev]); | |
514 | if (dma2[dev] >= 0) | |
515 | sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]); | |
516 | ||
43bcd973 | 517 | if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0) |
6bba41ac | 518 | return err; |
1da177e4 LT |
519 | |
520 | if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { | |
521 | if (snd_opl3_create(card, | |
522 | fm_port[dev], fm_port[dev] + 2, | |
523 | OPL3_HW_OPL3_CS, 0, &opl3) < 0) { | |
43bcd973 | 524 | printk(KERN_WARNING IDENT ": OPL3 not detected\n"); |
1da177e4 | 525 | } else { |
43bcd973 | 526 | if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) |
6bba41ac | 527 | return err; |
1da177e4 LT |
528 | } |
529 | } | |
530 | ||
531 | if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) { | |
532 | if (mpu_irq[dev] == SNDRV_AUTO_IRQ) | |
533 | mpu_irq[dev] = -1; | |
534 | if (snd_mpu401_uart_new(card, 0, MPU401_HW_CS4232, | |
535 | mpu_port[dev], 0, | |
536 | mpu_irq[dev], | |
65ca68b3 | 537 | mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0, NULL) < 0) |
43bcd973 | 538 | printk(KERN_WARNING IDENT ": MPU401 not detected\n"); |
1da177e4 | 539 | } |
43bcd973 | 540 | |
6bba41ac TI |
541 | return snd_card_register(card); |
542 | } | |
43bcd973 | 543 | |
5e24c1c1 TI |
544 | static int __devinit snd_cs423x_isa_match(struct device *pdev, |
545 | unsigned int dev) | |
6bba41ac | 546 | { |
5e24c1c1 TI |
547 | if (!enable[dev] || is_isapnp_selected(dev)) |
548 | return 0; | |
6bba41ac TI |
549 | |
550 | if (port[dev] == SNDRV_AUTO_PORT) { | |
5e24c1c1 TI |
551 | snd_printk(KERN_ERR "%s: please specify port\n", pdev->bus_id); |
552 | return 0; | |
6bba41ac TI |
553 | } |
554 | if (cport[dev] == SNDRV_AUTO_PORT) { | |
5e24c1c1 TI |
555 | snd_printk(KERN_ERR "%s: please specify cport\n", pdev->bus_id); |
556 | return 0; | |
557 | } | |
558 | if (irq[dev] == SNDRV_AUTO_IRQ) { | |
559 | snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id); | |
560 | return 0; | |
6bba41ac | 561 | } |
5e24c1c1 TI |
562 | if (dma1[dev] == SNDRV_AUTO_DMA) { |
563 | snd_printk(KERN_ERR "%s: please specify dma1\n", pdev->bus_id); | |
564 | return 0; | |
565 | } | |
566 | return 1; | |
567 | } | |
568 | ||
569 | static int __devinit snd_cs423x_isa_probe(struct device *pdev, | |
570 | unsigned int dev) | |
571 | { | |
572 | struct snd_card *card; | |
573 | int err; | |
6bba41ac TI |
574 | |
575 | card = snd_cs423x_card_new(dev); | |
576 | if (! card) | |
577 | return -ENOMEM; | |
5e24c1c1 | 578 | snd_card_set_dev(card, pdev); |
6bba41ac TI |
579 | if ((err = snd_cs423x_probe(card, dev)) < 0) { |
580 | snd_card_free(card); | |
581 | return err; | |
582 | } | |
ed7cb191 | 583 | |
5e24c1c1 | 584 | dev_set_drvdata(pdev, card); |
1da177e4 | 585 | return 0; |
6bba41ac | 586 | } |
43bcd973 | 587 | |
5e24c1c1 TI |
588 | static int __devexit snd_cs423x_isa_remove(struct device *pdev, |
589 | unsigned int dev) | |
6bba41ac | 590 | { |
5e24c1c1 TI |
591 | snd_card_free(dev_get_drvdata(pdev)); |
592 | dev_set_drvdata(pdev, NULL); | |
6bba41ac | 593 | return 0; |
1da177e4 LT |
594 | } |
595 | ||
6bba41ac TI |
596 | #ifdef CONFIG_PM |
597 | static int snd_cs423x_suspend(struct snd_card *card) | |
598 | { | |
599 | struct snd_card_cs4236 *acard = card->private_data; | |
600 | snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); | |
601 | acard->chip->suspend(acard->chip); | |
602 | return 0; | |
603 | } | |
604 | ||
605 | static int snd_cs423x_resume(struct snd_card *card) | |
606 | { | |
607 | struct snd_card_cs4236 *acard = card->private_data; | |
608 | acard->chip->resume(acard->chip); | |
609 | snd_power_change_state(card, SNDRV_CTL_POWER_D0); | |
610 | return 0; | |
611 | } | |
612 | ||
5e24c1c1 TI |
613 | static int snd_cs423x_isa_suspend(struct device *dev, unsigned int n, |
614 | pm_message_t state) | |
6bba41ac | 615 | { |
5e24c1c1 | 616 | return snd_cs423x_suspend(dev_get_drvdata(dev)); |
6bba41ac TI |
617 | } |
618 | ||
5e24c1c1 | 619 | static int snd_cs423x_isa_resume(struct device *dev, unsigned int n) |
6bba41ac | 620 | { |
5e24c1c1 | 621 | return snd_cs423x_resume(dev_get_drvdata(dev)); |
6bba41ac TI |
622 | } |
623 | #endif | |
624 | ||
5e24c1c1 TI |
625 | static struct isa_driver cs423x_isa_driver = { |
626 | .match = snd_cs423x_isa_match, | |
627 | .probe = snd_cs423x_isa_probe, | |
628 | .remove = __devexit_p(snd_cs423x_isa_remove), | |
6bba41ac | 629 | #ifdef CONFIG_PM |
5e24c1c1 TI |
630 | .suspend = snd_cs423x_isa_suspend, |
631 | .resume = snd_cs423x_isa_resume, | |
6bba41ac TI |
632 | #endif |
633 | .driver = { | |
83c51c0a | 634 | .name = DEV_NAME |
6bba41ac TI |
635 | }, |
636 | }; | |
637 | ||
638 | ||
1da177e4 | 639 | #ifdef CONFIG_PNP |
a9824c86 TI |
640 | #ifdef CS4232 |
641 | static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev, | |
642 | const struct pnp_device_id *id) | |
643 | { | |
644 | static int dev; | |
645 | int err; | |
646 | struct snd_card *card; | |
647 | ||
648 | if (pnp_device_is_isapnp(pdev)) | |
649 | return -ENOENT; /* we have another procedure - card */ | |
650 | for (; dev < SNDRV_CARDS; dev++) { | |
651 | if (enable[dev] && isapnp[dev]) | |
652 | break; | |
653 | } | |
654 | if (dev >= SNDRV_CARDS) | |
655 | return -ENODEV; | |
656 | ||
657 | card = snd_cs423x_card_new(dev); | |
658 | if (! card) | |
659 | return -ENOMEM; | |
660 | if ((err = snd_card_cs4232_pnp(dev, card->private_data, pdev)) < 0) { | |
661 | printk(KERN_ERR "PnP BIOS detection failed for " IDENT "\n"); | |
662 | snd_card_free(card); | |
663 | return err; | |
664 | } | |
665 | snd_card_set_dev(card, &pdev->dev); | |
666 | if ((err = snd_cs423x_probe(card, dev)) < 0) { | |
667 | snd_card_free(card); | |
668 | return err; | |
669 | } | |
670 | pnp_set_drvdata(pdev, card); | |
671 | dev++; | |
672 | return 0; | |
673 | } | |
674 | ||
675 | static void __devexit snd_cs4232_pnp_remove(struct pnp_dev * pdev) | |
676 | { | |
677 | snd_card_free(pnp_get_drvdata(pdev)); | |
678 | pnp_set_drvdata(pdev, NULL); | |
679 | } | |
680 | ||
681 | #ifdef CONFIG_PM | |
682 | static int snd_cs4232_pnp_suspend(struct pnp_dev *pdev, pm_message_t state) | |
683 | { | |
684 | return snd_cs423x_suspend(pnp_get_drvdata(pdev)); | |
685 | } | |
686 | ||
687 | static int snd_cs4232_pnp_resume(struct pnp_dev *pdev) | |
688 | { | |
689 | return snd_cs423x_resume(pnp_get_drvdata(pdev)); | |
690 | } | |
691 | #endif | |
692 | ||
693 | static struct pnp_driver cs4232_pnp_driver = { | |
694 | .name = "cs4232-pnpbios", | |
695 | .id_table = snd_cs4232_pnpbiosids, | |
696 | .probe = snd_cs4232_pnpbios_detect, | |
697 | .remove = __devexit_p(snd_cs4232_pnp_remove), | |
698 | #ifdef CONFIG_PM | |
699 | .suspend = snd_cs4232_pnp_suspend, | |
700 | .resume = snd_cs4232_pnp_resume, | |
701 | #endif | |
702 | }; | |
703 | #endif /* CS4232 */ | |
704 | ||
705 | static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard, | |
706 | const struct pnp_card_device_id *pid) | |
1da177e4 LT |
707 | { |
708 | static int dev; | |
6bba41ac | 709 | struct snd_card *card; |
1da177e4 LT |
710 | int res; |
711 | ||
712 | for ( ; dev < SNDRV_CARDS; dev++) { | |
6bba41ac TI |
713 | if (enable[dev] && isapnp[dev]) |
714 | break; | |
715 | } | |
716 | if (dev >= SNDRV_CARDS) | |
717 | return -ENODEV; | |
718 | ||
719 | card = snd_cs423x_card_new(dev); | |
720 | if (! card) | |
721 | return -ENOMEM; | |
a9824c86 TI |
722 | if ((res = snd_card_cs423x_pnpc(dev, card->private_data, pcard, pid)) < 0) { |
723 | printk(KERN_ERR "isapnp detection failed and probing for " IDENT | |
724 | " is not supported\n"); | |
6bba41ac TI |
725 | snd_card_free(card); |
726 | return res; | |
1da177e4 | 727 | } |
6bba41ac TI |
728 | snd_card_set_dev(card, &pcard->card->dev); |
729 | if ((res = snd_cs423x_probe(card, dev)) < 0) { | |
730 | snd_card_free(card); | |
731 | return res; | |
732 | } | |
733 | pnp_set_card_drvdata(pcard, card); | |
734 | dev++; | |
735 | return 0; | |
1da177e4 LT |
736 | } |
737 | ||
a9824c86 | 738 | static void __devexit snd_cs423x_pnpc_remove(struct pnp_card_link * pcard) |
1da177e4 | 739 | { |
6bba41ac TI |
740 | snd_card_free(pnp_get_card_drvdata(pcard)); |
741 | pnp_set_card_drvdata(pcard, NULL); | |
1da177e4 | 742 | } |
ed7cb191 | 743 | |
6bba41ac | 744 | #ifdef CONFIG_PM |
a9824c86 | 745 | static int snd_cs423x_pnpc_suspend(struct pnp_card_link *pcard, pm_message_t state) |
6bba41ac TI |
746 | { |
747 | return snd_cs423x_suspend(pnp_get_card_drvdata(pcard)); | |
748 | } | |
749 | ||
a9824c86 | 750 | static int snd_cs423x_pnpc_resume(struct pnp_card_link *pcard) |
6bba41ac TI |
751 | { |
752 | return snd_cs423x_resume(pnp_get_card_drvdata(pcard)); | |
753 | } | |
754 | #endif | |
755 | ||
1da177e4 LT |
756 | static struct pnp_card_driver cs423x_pnpc_driver = { |
757 | .flags = PNP_DRIVER_RES_DISABLE, | |
6bba41ac | 758 | .name = CS423X_ISAPNP_DRIVER, |
1da177e4 | 759 | .id_table = snd_cs423x_pnpids, |
a9824c86 TI |
760 | .probe = snd_cs423x_pnpc_detect, |
761 | .remove = __devexit_p(snd_cs423x_pnpc_remove), | |
6bba41ac | 762 | #ifdef CONFIG_PM |
a9824c86 TI |
763 | .suspend = snd_cs423x_pnpc_suspend, |
764 | .resume = snd_cs423x_pnpc_resume, | |
6bba41ac | 765 | #endif |
1da177e4 LT |
766 | }; |
767 | #endif /* CONFIG_PNP */ | |
768 | ||
769 | static int __init alsa_card_cs423x_init(void) | |
770 | { | |
5e24c1c1 | 771 | int err; |
1da177e4 | 772 | |
5e24c1c1 | 773 | err = isa_register_driver(&cs423x_isa_driver, SNDRV_CARDS); |
59b1b34f | 774 | #ifdef CONFIG_PNP |
609d7694 RH |
775 | if (!err) |
776 | isa_registered = 1; | |
a9824c86 | 777 | #ifdef CS4232 |
ed7cb191 BH |
778 | err = pnp_register_driver(&cs4232_pnp_driver); |
779 | if (!err) | |
f7a9275d | 780 | pnp_registered = 1; |
a9824c86 | 781 | #endif |
ed7cb191 BH |
782 | err = pnp_register_card_driver(&cs423x_pnpc_driver); |
783 | if (!err) | |
f7a9275d | 784 | pnpc_registered = 1; |
609d7694 RH |
785 | #ifdef CS4232 |
786 | if (pnp_registered) | |
787 | err = 0; | |
788 | #endif | |
789 | if (isa_registered) | |
790 | err = 0; | |
791 | #endif | |
792 | return err; | |
1da177e4 LT |
793 | } |
794 | ||
795 | static void __exit alsa_card_cs423x_exit(void) | |
796 | { | |
5e24c1c1 TI |
797 | #ifdef CONFIG_PNP |
798 | if (pnpc_registered) | |
799 | pnp_unregister_card_driver(&cs423x_pnpc_driver); | |
800 | #ifdef CS4232 | |
801 | if (pnp_registered) | |
802 | pnp_unregister_driver(&cs4232_pnp_driver); | |
803 | #endif | |
609d7694 RH |
804 | if (isa_registered) |
805 | #endif | |
806 | isa_unregister_driver(&cs423x_isa_driver); | |
1da177e4 LT |
807 | } |
808 | ||
809 | module_init(alsa_card_cs423x_init) | |
810 | module_exit(alsa_card_cs423x_exit) |