1/* 2 * Driver for generic CS4232/CS4235/CS4236/CS4236B/CS4237B/CS4238B/CS4239 chips 3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz> 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> 24#include <linux/err.h> 25#include <linux/isa.h> 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 35MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); 36MODULE_LICENSE("GPL"); 37#ifdef CS4232 38MODULE_DESCRIPTION("Cirrus Logic CS4232"); 39MODULE_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 46MODULE_DESCRIPTION("Cirrus Logic CS4235-9"); 47MODULE_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" 78#define DEV_NAME "cs4232" 79#else 80#define IDENT "CS4236+" 81#define DEV_NAME "cs4236" 82#endif 83 84static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 85static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 86static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */ 87#ifdef CONFIG_PNP 88static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; 89#endif 90static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 91static long cport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 92static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;/* PnP setup */ 93static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 94static long sb_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 95static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,11,12,15 */ 96static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 9,11,12,15 */ 97static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */ 98static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */ 99 100module_param_array(index, int, NULL, 0444); 101MODULE_PARM_DESC(index, "Index value for " IDENT " soundcard."); 102module_param_array(id, charp, NULL, 0444); 103MODULE_PARM_DESC(id, "ID string for " IDENT " soundcard."); 104module_param_array(enable, bool, NULL, 0444); 105MODULE_PARM_DESC(enable, "Enable " IDENT " soundcard."); 106#ifdef CONFIG_PNP 107module_param_array(isapnp, bool, NULL, 0444); 108MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard."); 109#endif 110module_param_array(port, long, NULL, 0444); 111MODULE_PARM_DESC(port, "Port # for " IDENT " driver."); 112module_param_array(cport, long, NULL, 0444); 113MODULE_PARM_DESC(cport, "Control port # for " IDENT " driver."); 114module_param_array(mpu_port, long, NULL, 0444); 115MODULE_PARM_DESC(mpu_port, "MPU-401 port # for " IDENT " driver."); 116module_param_array(fm_port, long, NULL, 0444); 117MODULE_PARM_DESC(fm_port, "FM port # for " IDENT " driver."); 118module_param_array(sb_port, long, NULL, 0444); 119MODULE_PARM_DESC(sb_port, "SB port # for " IDENT " driver (optional)."); 120module_param_array(irq, int, NULL, 0444); 121MODULE_PARM_DESC(irq, "IRQ # for " IDENT " driver."); 122module_param_array(mpu_irq, int, NULL, 0444); 123MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for " IDENT " driver."); 124module_param_array(dma1, int, NULL, 0444); 125MODULE_PARM_DESC(dma1, "DMA1 # for " IDENT " driver."); 126module_param_array(dma2, int, NULL, 0444); 127MODULE_PARM_DESC(dma2, "DMA2 # for " IDENT " driver."); 128 129#ifdef CONFIG_PNP 130static int isa_registered; 131static int pnpc_registered; 132#ifdef CS4232 133static int pnp_registered; 134#endif 135#endif /* CONFIG_PNP */ 136 137struct snd_card_cs4236 { 138 struct snd_cs4231 *chip; 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 147#ifdef CONFIG_PNP 148 149#ifdef CS4232 150/* 151 * PNP BIOS 152 */ 153static 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}; 161MODULE_DEVICE_TABLE(pnp, snd_cs4232_pnpbiosids); 162#endif /* CS4232 */ 163 164#ifdef CS4232 165#define CS423X_ISAPNP_DRIVER "cs4232_isapnp" 166static 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" } } }, 181 /* Netfinity 3000 on-board soundcard */ 182 { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC010f" } } }, 183 /* --- */ 184 { .id = "" } /* end */ 185}; 186#else /* CS4236 */ 187#define CS423X_ISAPNP_DRIVER "cs4236_isapnp" 188static 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 270MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids); 271 272/* WSS initialization */ 273static int __devinit snd_cs423x_pnp_init_wss(int dev, struct pnp_dev *pdev, 274 struct pnp_resource_table *cfg) 275{ 276 int err; 277 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) { 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]); 310 return 0; 311} 312 313/* CTRL initialization */ 314static 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 */ 336static 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 368static 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 385static 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 410 /* CTRL initialization */ 411 if (acard->ctrl && cport[dev] > 0) { 412 if (snd_cs423x_pnp_init_ctrl(dev, acard->ctrl, cfg) < 0) 413 goto error; 414 } 415 /* MPU initialization */ 416 if (acard->mpu && mpu_port[dev] > 0) { 417 if (snd_cs423x_pnp_init_mpu(dev, acard->mpu, cfg) < 0) 418 goto error; 419 } 420 kfree(cfg); 421 return 0; 422 423 error: 424 kfree(cfg); 425 return -EBUSY; 426} 427#endif /* CONFIG_PNP */ 428 429#ifdef CONFIG_PNP 430#define is_isapnp_selected(dev) isapnp[dev] 431#else 432#define is_isapnp_selected(dev) 0 433#endif 434 435static 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 442static struct snd_card *snd_cs423x_card_new(int dev) 443{ 444 struct snd_card *card; 445 446 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 447 sizeof(struct snd_card_cs4236)); 448 if (card == NULL) 449 return NULL; 450 card->private_free = snd_card_cs4236_free; 451 return card; 452} 453 454static 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; 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]); 466 return -EBUSY; 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, 478 &chip)) < 0) 479 return err; 480 acard->chip = chip; 481 482 if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) 483 return err; 484 485 if ((err = snd_cs4231_mixer(chip)) < 0) 486 return err; 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, 497 &chip)) < 0) 498 return err; 499 acard->chip = chip; 500 501 if ((err = snd_cs4236_pcm(chip, 0, &pcm)) < 0) 502 return err; 503 504 if ((err = snd_cs4236_mixer(chip)) < 0) 505 return err; 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 517 if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0) 518 return err; 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) { 524 printk(KERN_WARNING IDENT ": OPL3 not detected\n"); 525 } else { 526 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) 527 return err; 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], 537 mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0, NULL) < 0) 538 printk(KERN_WARNING IDENT ": MPU401 not detected\n"); 539 } 540 541 return snd_card_register(card); 542} 543 544static int __devinit snd_cs423x_isa_match(struct device *pdev, 545 unsigned int dev) 546{ 547 if (!enable[dev] || is_isapnp_selected(dev)) 548 return 0; 549 550 if (port[dev] == SNDRV_AUTO_PORT) { 551 snd_printk(KERN_ERR "%s: please specify port\n", pdev->bus_id); 552 return 0; 553 } 554 if (cport[dev] == SNDRV_AUTO_PORT) { 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; 561 } 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 569static int __devinit snd_cs423x_isa_probe(struct device *pdev, 570 unsigned int dev) 571{ 572 struct snd_card *card; 573 int err; 574 575 card = snd_cs423x_card_new(dev); 576 if (! card) 577 return -ENOMEM; 578 snd_card_set_dev(card, pdev); 579 if ((err = snd_cs423x_probe(card, dev)) < 0) { 580 snd_card_free(card); 581 return err; 582 } 583 584 dev_set_drvdata(pdev, card); 585 return 0; 586} 587 588static int __devexit snd_cs423x_isa_remove(struct device *pdev, 589 unsigned int dev) 590{ 591 snd_card_free(dev_get_drvdata(pdev)); 592 dev_set_drvdata(pdev, NULL); 593 return 0; 594} 595 596#ifdef CONFIG_PM 597static 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 605static 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 613static int snd_cs423x_isa_suspend(struct device *dev, unsigned int n, 614 pm_message_t state) 615{ 616 return snd_cs423x_suspend(dev_get_drvdata(dev)); 617} 618 619static int snd_cs423x_isa_resume(struct device *dev, unsigned int n) 620{ 621 return snd_cs423x_resume(dev_get_drvdata(dev)); 622} 623#endif 624 625static 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), 629#ifdef CONFIG_PM 630 .suspend = snd_cs423x_isa_suspend, 631 .resume = snd_cs423x_isa_resume, 632#endif 633 .driver = { 634 .name = DEV_NAME 635 }, 636}; 637 638 639#ifdef CONFIG_PNP 640#ifdef CS4232 641static 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 675static 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 682static 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 687static int snd_cs4232_pnp_resume(struct pnp_dev *pdev) 688{ 689 return snd_cs423x_resume(pnp_get_drvdata(pdev)); 690} 691#endif 692 693static 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 705static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard, 706 const struct pnp_card_device_id *pid) 707{ 708 static int dev; 709 struct snd_card *card; 710 int res; 711 712 for ( ; dev < SNDRV_CARDS; dev++) { 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; 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"); 725 snd_card_free(card); 726 return res; 727 } 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; 736} 737 738static void __devexit snd_cs423x_pnpc_remove(struct pnp_card_link * pcard) 739{ 740 snd_card_free(pnp_get_card_drvdata(pcard)); 741 pnp_set_card_drvdata(pcard, NULL); 742} 743 744#ifdef CONFIG_PM 745static int snd_cs423x_pnpc_suspend(struct pnp_card_link *pcard, pm_message_t state) 746{ 747 return snd_cs423x_suspend(pnp_get_card_drvdata(pcard)); 748} 749 750static int snd_cs423x_pnpc_resume(struct pnp_card_link *pcard) 751{ 752 return snd_cs423x_resume(pnp_get_card_drvdata(pcard)); 753} 754#endif 755 756static struct pnp_card_driver cs423x_pnpc_driver = { 757 .flags = PNP_DRIVER_RES_DISABLE, 758 .name = CS423X_ISAPNP_DRIVER, 759 .id_table = snd_cs423x_pnpids, 760 .probe = snd_cs423x_pnpc_detect, 761 .remove = __devexit_p(snd_cs423x_pnpc_remove), 762#ifdef CONFIG_PM 763 .suspend = snd_cs423x_pnpc_suspend, 764 .resume = snd_cs423x_pnpc_resume, 765#endif 766}; 767#endif /* CONFIG_PNP */ 768 769static int __init alsa_card_cs423x_init(void) 770{ 771 int err; 772 773 err = isa_register_driver(&cs423x_isa_driver, SNDRV_CARDS); 774#ifdef CONFIG_PNP 775 if (!err) 776 isa_registered = 1; 777#ifdef CS4232 778 err = pnp_register_driver(&cs4232_pnp_driver); 779 if (!err) 780 pnp_registered = 1; 781#endif 782 err = pnp_register_card_driver(&cs423x_pnpc_driver); 783 if (!err) 784 pnpc_registered = 1; 785#ifdef CS4232 786 if (pnp_registered) 787 err = 0; 788#endif 789 if (isa_registered) 790 err = 0; 791#endif 792 return err; 793} 794 795static void __exit alsa_card_cs423x_exit(void) 796{ 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 804 if (isa_registered) 805#endif 806 isa_unregister_driver(&cs423x_isa_driver); 807} 808 809module_init(alsa_card_cs423x_init) 810module_exit(alsa_card_cs423x_exit) 811