2 card-opti92x-ad1848.c - driver for OPTi 82c92x based soundcards.
3 Copyright (C) 1998-2000 by Massimo Piccioni <dafastidio@libero.it>
5 Part of this code was developed at the Italian Ministry of Air Defence,
6 Sixth Division (oh, che pace ...), Rome.
8 Thanks to Maria Grazia Pollarini, Salvatore Vassallo.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <sound/driver.h>
27 #include <linux/init.h>
28 #include <linux/err.h>
29 #include <linux/isa.h>
30 #include <linux/delay.h>
31 #include <linux/slab.h>
32 #include <linux/pnp.h>
33 #include <linux/moduleparam.h>
36 #include <sound/core.h>
38 #include <sound/cs4231.h>
41 #include <sound/ad1848.h>
43 #include <sound/control.h>
44 #include <sound/pcm.h>
47 #include <sound/mpu401.h>
48 #include <sound/opl3.h>
50 #include <sound/opl4.h>
52 #define SNDRV_LEGACY_FIND_FREE_IRQ
53 #define SNDRV_LEGACY_FIND_FREE_DMA
54 #include <sound/initval.h>
56 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
57 MODULE_LICENSE("GPL");
59 MODULE_DESCRIPTION("OPTi93X");
60 MODULE_SUPPORTED_DEVICE("{{OPTi,82C931/3}}");
63 MODULE_DESCRIPTION("OPTi92X - CS4231");
64 MODULE_SUPPORTED_DEVICE("{{OPTi,82C924 (CS4231)},"
65 "{OPTi,82C925 (CS4231)}}");
67 MODULE_DESCRIPTION("OPTi92X - AD1848");
68 MODULE_SUPPORTED_DEVICE("{{OPTi,82C924 (AD1848)},"
69 "{OPTi,82C925 (AD1848)},"
74 static int index
= SNDRV_DEFAULT_IDX1
; /* Index 0-MAX */
75 static char *id
= SNDRV_DEFAULT_STR1
; /* ID for this card */
76 //static int enable = SNDRV_DEFAULT_ENABLE1; /* Enable this card */
77 static int isapnp
= 1; /* Enable ISA PnP detection */
78 static long port
= SNDRV_DEFAULT_PORT1
; /* 0x530,0xe80,0xf40,0x604 */
79 static long mpu_port
= SNDRV_DEFAULT_PORT1
; /* 0x300,0x310,0x320,0x330 */
80 static long fm_port
= SNDRV_DEFAULT_PORT1
; /* 0x388 */
81 static int irq
= SNDRV_DEFAULT_IRQ1
; /* 5,7,9,10,11 */
82 static int mpu_irq
= SNDRV_DEFAULT_IRQ1
; /* 5,7,9,10 */
83 static int dma1
= SNDRV_DEFAULT_DMA1
; /* 0,1,3 */
84 #if defined(CS4231) || defined(OPTi93X)
85 static int dma2
= SNDRV_DEFAULT_DMA1
; /* 0,1,3 */
86 #endif /* CS4231 || OPTi93X */
88 module_param(index
, int, 0444);
89 MODULE_PARM_DESC(index
, "Index value for opti9xx based soundcard.");
90 module_param(id
, charp
, 0444);
91 MODULE_PARM_DESC(id
, "ID string for opti9xx based soundcard.");
92 //module_param(enable, bool, 0444);
93 //MODULE_PARM_DESC(enable, "Enable opti9xx soundcard.");
94 module_param(isapnp
, bool, 0444);
95 MODULE_PARM_DESC(isapnp
, "Enable ISA PnP detection for specified soundcard.");
96 module_param(port
, long, 0444);
97 MODULE_PARM_DESC(port
, "WSS port # for opti9xx driver.");
98 module_param(mpu_port
, long, 0444);
99 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for opti9xx driver.");
100 module_param(fm_port
, long, 0444);
101 MODULE_PARM_DESC(fm_port
, "FM port # for opti9xx driver.");
102 module_param(irq
, int, 0444);
103 MODULE_PARM_DESC(irq
, "WSS irq # for opti9xx driver.");
104 module_param(mpu_irq
, int, 0444);
105 MODULE_PARM_DESC(mpu_irq
, "MPU-401 irq # for opti9xx driver.");
106 module_param(dma1
, int, 0444);
107 MODULE_PARM_DESC(dma1
, "1st dma # for opti9xx driver.");
108 #if defined(CS4231) || defined(OPTi93X)
109 module_param(dma2
, int, 0444);
110 MODULE_PARM_DESC(dma2
, "2nd dma # for opti9xx driver.");
111 #endif /* CS4231 || OPTi93X */
113 #define OPTi9XX_HW_DETECT 0
114 #define OPTi9XX_HW_82C928 1
115 #define OPTi9XX_HW_82C929 2
116 #define OPTi9XX_HW_82C924 3
117 #define OPTi9XX_HW_82C925 4
118 #define OPTi9XX_HW_82C930 5
119 #define OPTi9XX_HW_82C931 6
120 #define OPTi9XX_HW_82C933 7
121 #define OPTi9XX_HW_LAST OPTi9XX_HW_82C933
123 #define OPTi9XX_MC_REG(n) n
127 #define OPTi93X_INDEX 0x00
128 #define OPTi93X_DATA 0x01
129 #define OPTi93X_STATUS 0x02
130 #define OPTi93X_DDATA 0x03
131 #define OPTi93X_PORT(chip, r) ((chip)->port + OPTi93X_##r)
133 #define OPTi93X_MIXOUT_LEFT 0x00
134 #define OPTi93X_MIXOUT_RIGHT 0x01
135 #define OPTi93X_CD_LEFT_INPUT 0x02
136 #define OPTi93X_CD_RIGHT_INPUT 0x03
137 #define OPTi930_AUX_LEFT_INPUT 0x04
138 #define OPTi930_AUX_RIGHT_INPUT 0x05
139 #define OPTi931_FM_LEFT_INPUT 0x04
140 #define OPTi931_FM_RIGHT_INPUT 0x05
141 #define OPTi93X_DAC_LEFT 0x06
142 #define OPTi93X_DAC_RIGHT 0x07
143 #define OPTi93X_PLAY_FORMAT 0x08
144 #define OPTi93X_IFACE_CONF 0x09
145 #define OPTi93X_PIN_CTRL 0x0a
146 #define OPTi93X_ERR_INIT 0x0b
147 #define OPTi93X_ID 0x0c
148 #define OPTi93X_PLAY_UPR_CNT 0x0e
149 #define OPTi93X_PLAY_LWR_CNT 0x0f
150 #define OPTi931_AUX_LEFT_INPUT 0x10
151 #define OPTi931_AUX_RIGHT_INPUT 0x11
152 #define OPTi93X_LINE_LEFT_INPUT 0x12
153 #define OPTi93X_LINE_RIGHT_INPUT 0x13
154 #define OPTi93X_MIC_LEFT_INPUT 0x14
155 #define OPTi93X_MIC_RIGHT_INPUT 0x15
156 #define OPTi93X_OUT_LEFT 0x16
157 #define OPTi93X_OUT_RIGHT 0x17
158 #define OPTi93X_CAPT_FORMAT 0x1c
159 #define OPTi93X_CAPT_UPR_CNT 0x1e
160 #define OPTi93X_CAPT_LWR_CNT 0x1f
162 #define OPTi93X_TRD 0x20
163 #define OPTi93X_MCE 0x40
164 #define OPTi93X_INIT 0x80
166 #define OPTi93X_MIXOUT_MIC_GAIN 0x20
167 #define OPTi93X_MIXOUT_LINE 0x00
168 #define OPTi93X_MIXOUT_CD 0x40
169 #define OPTi93X_MIXOUT_MIC 0x80
170 #define OPTi93X_MIXOUT_MIXER 0xc0
172 #define OPTi93X_STEREO 0x10
173 #define OPTi93X_LINEAR_8 0x00
174 #define OPTi93X_ULAW_8 0x20
175 #define OPTi93X_LINEAR_16_LIT 0x40
176 #define OPTi93X_ALAW_8 0x60
177 #define OPTi93X_ADPCM_16 0xa0
178 #define OPTi93X_LINEAR_16_BIG 0xc0
180 #define OPTi93X_CAPTURE_PIO 0x80
181 #define OPTi93X_PLAYBACK_PIO 0x40
182 #define OPTi93X_AUTOCALIB 0x08
183 #define OPTi93X_SINGLE_DMA 0x04
184 #define OPTi93X_CAPTURE_ENABLE 0x02
185 #define OPTi93X_PLAYBACK_ENABLE 0x01
187 #define OPTi93X_IRQ_ENABLE 0x02
189 #define OPTi93X_DMA_REQUEST 0x10
190 #define OPTi93X_CALIB_IN_PROGRESS 0x20
192 #define OPTi93X_IRQ_PLAYBACK 0x04
193 #define OPTi93X_IRQ_CAPTURE 0x08
198 struct resource
*res_port
;
203 struct snd_opti9xx
*chip
;
204 unsigned short hardware
;
205 unsigned char image
[32];
207 unsigned char mce_bit
;
213 struct snd_card
*card
;
215 struct snd_pcm_substream
*playback_substream
;
216 struct snd_pcm_substream
*capture_substream
;
217 unsigned int p_dma_size
;
218 unsigned int c_dma_size
;
221 #define OPTi93X_MODE_NONE 0x00
222 #define OPTi93X_MODE_PLAY 0x01
223 #define OPTi93X_MODE_CAPTURE 0x02
224 #define OPTi93X_MODE_OPEN (OPTi93X_MODE_PLAY | OPTi93X_MODE_CAPTURE)
229 unsigned short hardware
;
230 unsigned char password
;
233 unsigned long mc_base
;
234 struct resource
*res_mc_base
;
235 unsigned long mc_base_size
;
237 unsigned long mc_indir_index
;
239 unsigned long pwd_reg
;
246 #if defined(CS4231) || defined(OPTi93X)
248 #endif /* CS4231 || OPTi93X */
257 struct pnp_dev
*devmpu
;
258 #endif /* CONFIG_PNP */
261 static int snd_opti9xx_pnp_is_probed
;
265 static struct pnp_card_device_id snd_opti9xx_pnpids
[] = {
268 { .id
= "OPT0924", .devs
= { { "OPT0000" }, { "OPT0002" } }, .driver_data
= 0x0924 },
270 { .id
= "OPT0925", .devs
= { { "OPT9250" }, { "OPT0002" } }, .driver_data
= 0x0925 },
273 { .id
= "OPT0931", .devs
= { { "OPT9310" }, { "OPT0002" } }, .driver_data
= 0x0931 },
278 MODULE_DEVICE_TABLE(pnp_card
, snd_opti9xx_pnpids
);
280 #endif /* CONFIG_PNP */
283 #define DEV_NAME "opti93x"
285 #define DEV_NAME "opti92x"
288 static char * snd_opti9xx_names
[] = {
292 "82C930", "82C931", "82C933"
296 static long __devinit
snd_legacy_find_free_ioport(long *port_table
, long size
)
298 while (*port_table
!= -1) {
299 if (request_region(*port_table
, size
, "ALSA test")) {
300 release_region(*port_table
, size
);
308 static int __devinit
snd_opti9xx_init(struct snd_opti9xx
*chip
,
309 unsigned short hardware
)
311 static int opti9xx_mc_size
[] = {7, 7, 10, 10, 2, 2, 2};
313 chip
->hardware
= hardware
;
314 strcpy(chip
->name
, snd_opti9xx_names
[hardware
]);
316 chip
->mc_base_size
= opti9xx_mc_size
[hardware
];
318 spin_lock_init(&chip
->lock
);
323 #if defined(CS4231) || defined (OPTi93X)
325 #endif /* CS4231 || OPTi93X */
332 case OPTi9XX_HW_82C928
:
333 case OPTi9XX_HW_82C929
:
334 chip
->mc_base
= 0xf8c;
335 chip
->password
= (hardware
== OPTi9XX_HW_82C928
) ? 0xe2 : 0xe3;
339 case OPTi9XX_HW_82C924
:
340 case OPTi9XX_HW_82C925
:
341 chip
->mc_base
= 0xf8c;
342 chip
->password
= 0xe5;
347 case OPTi9XX_HW_82C930
:
348 case OPTi9XX_HW_82C931
:
349 case OPTi9XX_HW_82C933
:
350 chip
->mc_base
= (hardware
== OPTi9XX_HW_82C930
) ? 0xf8f : 0xf8d;
351 chip
->mc_indir_index
= 0xe0e;
352 chip
->password
= 0xe4;
358 snd_printk("chip %d not supported\n", hardware
);
364 static unsigned char snd_opti9xx_read(struct snd_opti9xx
*chip
,
368 unsigned char retval
= 0xff;
370 spin_lock_irqsave(&chip
->lock
, flags
);
371 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
373 switch (chip
->hardware
) {
375 case OPTi9XX_HW_82C924
:
376 case OPTi9XX_HW_82C925
:
378 outb(reg
, chip
->mc_base
+ 8);
379 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
380 retval
= inb(chip
->mc_base
+ 9);
384 case OPTi9XX_HW_82C928
:
385 case OPTi9XX_HW_82C929
:
386 retval
= inb(chip
->mc_base
+ reg
);
390 case OPTi9XX_HW_82C930
:
391 case OPTi9XX_HW_82C931
:
392 case OPTi9XX_HW_82C933
:
393 outb(reg
, chip
->mc_indir_index
);
394 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
395 retval
= inb(chip
->mc_indir_index
+ 1);
400 snd_printk("chip %d not supported\n", chip
->hardware
);
403 spin_unlock_irqrestore(&chip
->lock
, flags
);
407 static void snd_opti9xx_write(struct snd_opti9xx
*chip
, unsigned char reg
,
412 spin_lock_irqsave(&chip
->lock
, flags
);
413 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
415 switch (chip
->hardware
) {
417 case OPTi9XX_HW_82C924
:
418 case OPTi9XX_HW_82C925
:
420 outb(reg
, chip
->mc_base
+ 8);
421 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
422 outb(value
, chip
->mc_base
+ 9);
426 case OPTi9XX_HW_82C928
:
427 case OPTi9XX_HW_82C929
:
428 outb(value
, chip
->mc_base
+ reg
);
432 case OPTi9XX_HW_82C930
:
433 case OPTi9XX_HW_82C931
:
434 case OPTi9XX_HW_82C933
:
435 outb(reg
, chip
->mc_indir_index
);
436 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
437 outb(value
, chip
->mc_indir_index
+ 1);
442 snd_printk("chip %d not supported\n", chip
->hardware
);
445 spin_unlock_irqrestore(&chip
->lock
, flags
);
449 #define snd_opti9xx_write_mask(chip, reg, value, mask) \
450 snd_opti9xx_write(chip, reg, \
451 (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
454 static int __devinit
snd_opti9xx_configure(struct snd_opti9xx
*chip
)
456 unsigned char wss_base_bits
;
457 unsigned char irq_bits
;
458 unsigned char dma_bits
;
459 unsigned char mpu_port_bits
= 0;
460 unsigned char mpu_irq_bits
;
462 switch (chip
->hardware
) {
464 case OPTi9XX_HW_82C924
:
465 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0xf0, 0xfc);
466 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6), 0x02, 0x02);
468 case OPTi9XX_HW_82C925
:
469 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), 0x80, 0x80);
470 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2), 0x00, 0x20);
471 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(3), 0xf0, 0xff);
473 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x02, 0x02);
475 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x00, 0x02);
479 case OPTi9XX_HW_82C928
:
480 case OPTi9XX_HW_82C929
:
481 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), 0x80, 0x80);
482 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2), 0x00, 0x20);
484 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xa2, 0xae);
486 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0x00, 0x0c);
488 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x02, 0x02);
490 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x00, 0x02);
495 case OPTi9XX_HW_82C930
:
496 case OPTi9XX_HW_82C931
:
497 case OPTi9XX_HW_82C933
:
498 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6), 0x02, 0x03);
499 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(3), 0x00, 0xff);
500 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0x10 |
501 (chip
->hardware
== OPTi9XX_HW_82C930
? 0x00 : 0x04),
503 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x20, 0xbf);
508 snd_printk("chip %d not supported\n", chip
->hardware
);
512 switch (chip
->wss_base
) {
514 wss_base_bits
= 0x00;
517 wss_base_bits
= 0x03;
520 wss_base_bits
= 0x01;
523 wss_base_bits
= 0x02;
526 snd_printk("WSS port 0x%lx not valid\n", chip
->wss_base
);
529 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), wss_base_bits
<< 4, 0x30);
537 //#endif /* OPTi93X */
551 snd_printk("WSS irq # %d not valid\n", chip
->irq
);
552 goto __skip_resources
;
555 switch (chip
->dma1
) {
566 snd_printk("WSS dma1 # %d not valid\n", chip
->dma1
);
567 goto __skip_resources
;
570 #if defined(CS4231) || defined(OPTi93X)
571 if (chip
->dma1
== chip
->dma2
) {
572 snd_printk("don't want to share dmas\n");
576 switch (chip
->dma2
) {
581 snd_printk("WSS dma2 # %d not valid\n", chip
->dma2
);
582 goto __skip_resources
;
585 #endif /* CS4231 || OPTi93X */
588 outb(irq_bits
<< 3 | dma_bits
, chip
->wss_base
);
590 snd_opti9xx_write(chip
, OPTi9XX_MC_REG(3), (irq_bits
<< 3 | dma_bits
));
594 if (chip
->hardware
> OPTi9XX_HW_82C928
) {
595 switch (chip
->mpu_port
) {
600 mpu_port_bits
= 0x03;
603 mpu_port_bits
= 0x02;
606 mpu_port_bits
= 0x01;
609 mpu_port_bits
= 0x00;
612 snd_printk("MPU-401 port 0x%lx not valid\n",
617 switch (chip
->mpu_irq
) {
631 snd_printk("MPU-401 irq # %d not valid\n",
636 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6),
637 (chip
->mpu_port
<= 0) ? 0x00 :
638 0x80 | mpu_port_bits
<< 5 | mpu_irq_bits
<< 3,
648 static unsigned char snd_opti93x_default_image
[32] =
650 0x00, /* 00/00 - l_mixout_outctrl */
651 0x00, /* 01/01 - r_mixout_outctrl */
652 0x88, /* 02/02 - l_cd_inctrl */
653 0x88, /* 03/03 - r_cd_inctrl */
654 0x88, /* 04/04 - l_a1/fm_inctrl */
655 0x88, /* 05/05 - r_a1/fm_inctrl */
656 0x80, /* 06/06 - l_dac_inctrl */
657 0x80, /* 07/07 - r_dac_inctrl */
658 0x00, /* 08/08 - ply_dataform_reg */
659 0x00, /* 09/09 - if_conf */
660 0x00, /* 0a/10 - pin_ctrl */
661 0x00, /* 0b/11 - err_init_reg */
662 0x0a, /* 0c/12 - id_reg */
663 0x00, /* 0d/13 - reserved */
664 0x00, /* 0e/14 - ply_upcount_reg */
665 0x00, /* 0f/15 - ply_lowcount_reg */
666 0x88, /* 10/16 - reserved/l_a1_inctrl */
667 0x88, /* 11/17 - reserved/r_a1_inctrl */
668 0x88, /* 12/18 - l_line_inctrl */
669 0x88, /* 13/19 - r_line_inctrl */
670 0x88, /* 14/20 - l_mic_inctrl */
671 0x88, /* 15/21 - r_mic_inctrl */
672 0x80, /* 16/22 - l_out_outctrl */
673 0x80, /* 17/23 - r_out_outctrl */
674 0x00, /* 18/24 - reserved */
675 0x00, /* 19/25 - reserved */
676 0x00, /* 1a/26 - reserved */
677 0x00, /* 1b/27 - reserved */
678 0x00, /* 1c/28 - cap_dataform_reg */
679 0x00, /* 1d/29 - reserved */
680 0x00, /* 1e/30 - cap_upcount_reg */
681 0x00 /* 1f/31 - cap_lowcount_reg */
685 static int snd_opti93x_busy_wait(struct snd_opti93x
*chip
)
689 for (timeout
= 250; timeout
-- > 0; udelay(10))
690 if (!(inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_INIT
))
693 snd_printk("chip still busy.\n");
697 static unsigned char snd_opti93x_in(struct snd_opti93x
*chip
, unsigned char reg
)
699 snd_opti93x_busy_wait(chip
);
700 outb(chip
->mce_bit
| (reg
& 0x1f), OPTi93X_PORT(chip
, INDEX
));
701 return inb(OPTi93X_PORT(chip
, DATA
));
704 static void snd_opti93x_out(struct snd_opti93x
*chip
, unsigned char reg
,
707 snd_opti93x_busy_wait(chip
);
708 outb(chip
->mce_bit
| (reg
& 0x1f), OPTi93X_PORT(chip
, INDEX
));
709 outb(value
, OPTi93X_PORT(chip
, DATA
));
712 static void snd_opti93x_out_image(struct snd_opti93x
*chip
, unsigned char reg
,
715 snd_opti93x_out(chip
, reg
, chip
->image
[reg
] = value
);
718 static void snd_opti93x_out_mask(struct snd_opti93x
*chip
, unsigned char reg
,
719 unsigned char mask
, unsigned char value
)
721 snd_opti93x_out_image(chip
, reg
,
722 (chip
->image
[reg
] & ~mask
) | (value
& mask
));
726 static void snd_opti93x_mce_up(struct snd_opti93x
*chip
)
728 snd_opti93x_busy_wait(chip
);
730 chip
->mce_bit
= OPTi93X_MCE
;
731 if (!(inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_MCE
))
732 outb(chip
->mce_bit
, OPTi93X_PORT(chip
, INDEX
));
735 static void snd_opti93x_mce_down(struct snd_opti93x
*chip
)
737 snd_opti93x_busy_wait(chip
);
740 if (inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_MCE
)
741 outb(chip
->mce_bit
, OPTi93X_PORT(chip
, INDEX
));
744 #define snd_opti93x_mute_reg(chip, reg, mute) \
745 snd_opti93x_out(chip, reg, mute ? 0x80 : chip->image[reg]);
747 static void snd_opti93x_mute(struct snd_opti93x
*chip
, int mute
)
750 if (chip
->mute
== mute
)
755 snd_opti93x_mute_reg(chip
, OPTi93X_CD_LEFT_INPUT
, mute
);
756 snd_opti93x_mute_reg(chip
, OPTi93X_CD_RIGHT_INPUT
, mute
);
757 switch (chip
->hardware
) {
758 case OPTi9XX_HW_82C930
:
759 snd_opti93x_mute_reg(chip
, OPTi930_AUX_LEFT_INPUT
, mute
);
760 snd_opti93x_mute_reg(chip
, OPTi930_AUX_RIGHT_INPUT
, mute
);
762 case OPTi9XX_HW_82C931
:
763 case OPTi9XX_HW_82C933
:
764 snd_opti93x_mute_reg(chip
, OPTi931_FM_LEFT_INPUT
, mute
);
765 snd_opti93x_mute_reg(chip
, OPTi931_FM_RIGHT_INPUT
, mute
);
766 snd_opti93x_mute_reg(chip
, OPTi931_AUX_LEFT_INPUT
, mute
);
767 snd_opti93x_mute_reg(chip
, OPTi931_AUX_RIGHT_INPUT
, mute
);
769 snd_opti93x_mute_reg(chip
, OPTi93X_DAC_LEFT
, mute
);
770 snd_opti93x_mute_reg(chip
, OPTi93X_DAC_RIGHT
, mute
);
771 snd_opti93x_mute_reg(chip
, OPTi93X_LINE_LEFT_INPUT
, mute
);
772 snd_opti93x_mute_reg(chip
, OPTi93X_LINE_RIGHT_INPUT
, mute
);
773 snd_opti93x_mute_reg(chip
, OPTi93X_MIC_LEFT_INPUT
, mute
);
774 snd_opti93x_mute_reg(chip
, OPTi93X_MIC_RIGHT_INPUT
, mute
);
775 snd_opti93x_mute_reg(chip
, OPTi93X_OUT_LEFT
, mute
);
776 snd_opti93x_mute_reg(chip
, OPTi93X_OUT_RIGHT
, mute
);
780 static unsigned int snd_opti93x_get_count(unsigned char format
,
783 switch (format
& 0xe0) {
784 case OPTi93X_LINEAR_16_LIT
:
785 case OPTi93X_LINEAR_16_BIG
:
788 case OPTi93X_ADPCM_16
:
791 return (format
& OPTi93X_STEREO
) ? (size
>> 1) : size
;
794 static unsigned int rates
[] = { 5512, 6615, 8000, 9600, 11025, 16000,
795 18900, 22050, 27428, 32000, 33075, 37800,
797 #define RATES ARRAY_SIZE(rates)
799 static struct snd_pcm_hw_constraint_list hw_constraints_rates
= {
805 static unsigned char bits
[] = { 0x01, 0x0f, 0x00, 0x0e, 0x03, 0x02,
806 0x05, 0x07, 0x04, 0x06, 0x0d, 0x09,
809 static unsigned char snd_opti93x_get_freq(unsigned int rate
)
813 for (i
= 0; i
< RATES
; i
++) {
814 if (rate
== rates
[i
])
818 return bits
[RATES
-1];
821 static unsigned char snd_opti93x_get_format(struct snd_opti93x
*chip
,
822 unsigned int format
, int channels
)
824 unsigned char retval
= OPTi93X_LINEAR_8
;
827 case SNDRV_PCM_FORMAT_MU_LAW
:
828 retval
= OPTi93X_ULAW_8
;
830 case SNDRV_PCM_FORMAT_A_LAW
:
831 retval
= OPTi93X_ALAW_8
;
833 case SNDRV_PCM_FORMAT_S16_LE
:
834 retval
= OPTi93X_LINEAR_16_LIT
;
836 case SNDRV_PCM_FORMAT_S16_BE
:
837 retval
= OPTi93X_LINEAR_16_BIG
;
839 case SNDRV_PCM_FORMAT_IMA_ADPCM
:
840 retval
= OPTi93X_ADPCM_16
;
842 return (channels
> 1) ? (retval
| OPTi93X_STEREO
) : retval
;
846 static void snd_opti93x_playback_format(struct snd_opti93x
*chip
, unsigned char fmt
)
850 snd_opti93x_mute(chip
, 1);
852 snd_opti93x_mce_up(chip
);
853 mask
= (chip
->mode
& OPTi93X_MODE_CAPTURE
) ? 0xf0 : 0xff;
854 snd_opti93x_out_mask(chip
, OPTi93X_PLAY_FORMAT
, mask
, fmt
);
855 snd_opti93x_mce_down(chip
);
857 snd_opti93x_mute(chip
, 0);
860 static void snd_opti93x_capture_format(struct snd_opti93x
*chip
, unsigned char fmt
)
862 snd_opti93x_mute(chip
, 1);
864 snd_opti93x_mce_up(chip
);
865 if (!(chip
->mode
& OPTi93X_MODE_PLAY
))
866 snd_opti93x_out_mask(chip
, OPTi93X_PLAY_FORMAT
, 0x0f, fmt
);
868 fmt
= chip
->image
[OPTi93X_PLAY_FORMAT
] & 0xf0;
869 snd_opti93x_out_image(chip
, OPTi93X_CAPT_FORMAT
, fmt
);
870 snd_opti93x_mce_down(chip
);
872 snd_opti93x_mute(chip
, 0);
876 static int snd_opti93x_open(struct snd_opti93x
*chip
, unsigned int mode
)
880 spin_lock_irqsave(&chip
->lock
, flags
);
882 if (chip
->mode
& mode
) {
883 spin_unlock_irqrestore(&chip
->lock
, flags
);
887 if (!(chip
->mode
& OPTi93X_MODE_OPEN
)) {
888 outb(0x00, OPTi93X_PORT(chip
, STATUS
));
889 snd_opti93x_out_mask(chip
, OPTi93X_PIN_CTRL
,
890 OPTi93X_IRQ_ENABLE
, OPTi93X_IRQ_ENABLE
);
896 spin_unlock_irqrestore(&chip
->lock
, flags
);
900 static void snd_opti93x_close(struct snd_opti93x
*chip
, unsigned int mode
)
904 spin_lock_irqsave(&chip
->lock
, flags
);
907 if (chip
->mode
& OPTi93X_MODE_OPEN
) {
908 spin_unlock_irqrestore(&chip
->lock
, flags
);
912 snd_opti93x_mute(chip
, 1);
914 outb(0, OPTi93X_PORT(chip
, STATUS
));
915 snd_opti93x_out_mask(chip
, OPTi93X_PIN_CTRL
, OPTi93X_IRQ_ENABLE
,
916 ~OPTi93X_IRQ_ENABLE
);
918 snd_opti93x_mce_up(chip
);
919 snd_opti93x_out_image(chip
, OPTi93X_IFACE_CONF
, 0x00);
920 snd_opti93x_mce_down(chip
);
923 snd_opti93x_mute(chip
, 0);
924 spin_unlock_irqrestore(&chip
->lock
, flags
);
927 static int snd_opti93x_trigger(struct snd_pcm_substream
*substream
,
928 unsigned char what
, int cmd
)
930 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
933 case SNDRV_PCM_TRIGGER_START
:
934 case SNDRV_PCM_TRIGGER_STOP
:
936 unsigned int what
= 0;
937 struct snd_pcm_substream
*s
;
938 snd_pcm_group_for_each_entry(s
, substream
) {
939 if (s
== chip
->playback_substream
) {
940 what
|= OPTi93X_PLAYBACK_ENABLE
;
941 snd_pcm_trigger_done(s
, substream
);
942 } else if (s
== chip
->capture_substream
) {
943 what
|= OPTi93X_CAPTURE_ENABLE
;
944 snd_pcm_trigger_done(s
, substream
);
947 spin_lock(&chip
->lock
);
948 if (cmd
== SNDRV_PCM_TRIGGER_START
) {
949 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
, what
, what
);
950 if (what
& OPTi93X_CAPTURE_ENABLE
)
953 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
, what
, 0x00);
954 spin_unlock(&chip
->lock
);
963 static int snd_opti93x_playback_trigger(struct snd_pcm_substream
*substream
, int cmd
)
965 return snd_opti93x_trigger(substream
,
966 OPTi93X_PLAYBACK_ENABLE
, cmd
);
969 static int snd_opti93x_capture_trigger(struct snd_pcm_substream
*substream
, int cmd
)
971 return snd_opti93x_trigger(substream
,
972 OPTi93X_CAPTURE_ENABLE
, cmd
);
975 static int snd_opti93x_hw_params(struct snd_pcm_substream
*substream
,
976 struct snd_pcm_hw_params
*hw_params
)
978 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
982 static int snd_opti93x_hw_free(struct snd_pcm_substream
*substream
)
984 snd_pcm_lib_free_pages(substream
);
989 static int snd_opti93x_playback_prepare(struct snd_pcm_substream
*substream
)
991 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
992 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
994 unsigned char format
;
995 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
996 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
998 spin_lock_irqsave(&chip
->lock
, flags
);
1000 chip
->p_dma_size
= size
;
1001 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
,
1002 OPTi93X_PLAYBACK_ENABLE
| OPTi93X_PLAYBACK_PIO
,
1003 ~(OPTi93X_PLAYBACK_ENABLE
| OPTi93X_PLAYBACK_PIO
));
1005 snd_dma_program(chip
->dma1
, runtime
->dma_addr
, size
,
1006 DMA_MODE_WRITE
| DMA_AUTOINIT
);
1008 format
= snd_opti93x_get_freq(runtime
->rate
);
1009 format
|= snd_opti93x_get_format(chip
, runtime
->format
,
1011 snd_opti93x_playback_format(chip
, format
);
1012 format
= chip
->image
[OPTi93X_PLAY_FORMAT
];
1014 count
= snd_opti93x_get_count(format
, count
) - 1;
1015 snd_opti93x_out_image(chip
, OPTi93X_PLAY_LWR_CNT
, count
);
1016 snd_opti93x_out_image(chip
, OPTi93X_PLAY_UPR_CNT
, count
>> 8);
1018 spin_unlock_irqrestore(&chip
->lock
, flags
);
1022 static int snd_opti93x_capture_prepare(struct snd_pcm_substream
*substream
)
1024 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1025 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1026 unsigned long flags
;
1027 unsigned char format
;
1028 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
1029 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
1031 spin_lock_irqsave(&chip
->lock
, flags
);
1033 chip
->c_dma_size
= size
;
1034 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
,
1035 OPTi93X_CAPTURE_ENABLE
| OPTi93X_CAPTURE_PIO
, 0);
1037 snd_dma_program(chip
->dma2
, runtime
->dma_addr
, size
,
1038 DMA_MODE_READ
| DMA_AUTOINIT
);
1040 format
= snd_opti93x_get_freq(runtime
->rate
);
1041 format
|= snd_opti93x_get_format(chip
, runtime
->format
,
1043 snd_opti93x_capture_format(chip
, format
);
1044 format
= chip
->image
[OPTi93X_CAPT_FORMAT
];
1046 count
= snd_opti93x_get_count(format
, count
) - 1;
1047 snd_opti93x_out_image(chip
, OPTi93X_CAPT_LWR_CNT
, count
);
1048 snd_opti93x_out_image(chip
, OPTi93X_CAPT_UPR_CNT
, count
>> 8);
1050 spin_unlock_irqrestore(&chip
->lock
, flags
);
1054 static snd_pcm_uframes_t
snd_opti93x_playback_pointer(struct snd_pcm_substream
*substream
)
1056 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1059 if (!(chip
->image
[OPTi93X_IFACE_CONF
] & OPTi93X_PLAYBACK_ENABLE
))
1062 ptr
= snd_dma_pointer(chip
->dma1
, chip
->p_dma_size
);
1063 return bytes_to_frames(substream
->runtime
, ptr
);
1066 static snd_pcm_uframes_t
snd_opti93x_capture_pointer(struct snd_pcm_substream
*substream
)
1068 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1071 if (!(chip
->image
[OPTi93X_IFACE_CONF
] & OPTi93X_CAPTURE_ENABLE
))
1074 ptr
= snd_dma_pointer(chip
->dma2
, chip
->c_dma_size
);
1075 return bytes_to_frames(substream
->runtime
, ptr
);
1079 static void snd_opti93x_overrange(struct snd_opti93x
*chip
)
1081 unsigned long flags
;
1083 spin_lock_irqsave(&chip
->lock
, flags
);
1085 if (snd_opti93x_in(chip
, OPTi93X_ERR_INIT
) & (0x08 | 0x02))
1086 chip
->capture_substream
->runtime
->overrange
++;
1088 spin_unlock_irqrestore(&chip
->lock
, flags
);
1091 static irqreturn_t
snd_opti93x_interrupt(int irq
, void *dev_id
)
1093 struct snd_opti93x
*codec
= dev_id
;
1094 unsigned char status
;
1096 status
= snd_opti9xx_read(codec
->chip
, OPTi9XX_MC_REG(11));
1097 if ((status
& OPTi93X_IRQ_PLAYBACK
) && codec
->playback_substream
)
1098 snd_pcm_period_elapsed(codec
->playback_substream
);
1099 if ((status
& OPTi93X_IRQ_CAPTURE
) && codec
->capture_substream
) {
1100 snd_opti93x_overrange(codec
);
1101 snd_pcm_period_elapsed(codec
->capture_substream
);
1103 outb(0x00, OPTi93X_PORT(codec
, STATUS
));
1108 static struct snd_pcm_hardware snd_opti93x_playback
= {
1109 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1110 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
),
1111 .formats
= (SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
| SNDRV_PCM_FMTBIT_IMA_ADPCM
|
1112 SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
),
1113 .rates
= SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_8000_48000
,
1118 .buffer_bytes_max
= (128*1024),
1119 .period_bytes_min
= 64,
1120 .period_bytes_max
= (128*1024),
1122 .periods_max
= 1024,
1126 static struct snd_pcm_hardware snd_opti93x_capture
= {
1127 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1128 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
),
1129 .formats
= (SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
| SNDRV_PCM_FMTBIT_IMA_ADPCM
|
1130 SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
),
1131 .rates
= SNDRV_PCM_RATE_8000_48000
,
1136 .buffer_bytes_max
= (128*1024),
1137 .period_bytes_min
= 64,
1138 .period_bytes_max
= (128*1024),
1140 .periods_max
= 1024,
1144 static int snd_opti93x_playback_open(struct snd_pcm_substream
*substream
)
1147 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1148 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1150 if ((error
= snd_opti93x_open(chip
, OPTi93X_MODE_PLAY
)) < 0)
1152 snd_pcm_set_sync(substream
);
1153 chip
->playback_substream
= substream
;
1154 runtime
->hw
= snd_opti93x_playback
;
1155 snd_pcm_limit_isa_dma_size(chip
->dma1
, &runtime
->hw
.buffer_bytes_max
);
1156 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
);
1160 static int snd_opti93x_capture_open(struct snd_pcm_substream
*substream
)
1163 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1164 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1166 if ((error
= snd_opti93x_open(chip
, OPTi93X_MODE_CAPTURE
)) < 0)
1168 runtime
->hw
= snd_opti93x_capture
;
1169 snd_pcm_set_sync(substream
);
1170 chip
->capture_substream
= substream
;
1171 snd_pcm_limit_isa_dma_size(chip
->dma2
, &runtime
->hw
.buffer_bytes_max
);
1172 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
);
1176 static int snd_opti93x_playback_close(struct snd_pcm_substream
*substream
)
1178 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1180 chip
->playback_substream
= NULL
;
1181 snd_opti93x_close(chip
, OPTi93X_MODE_PLAY
);
1185 static int snd_opti93x_capture_close(struct snd_pcm_substream
*substream
)
1187 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1189 chip
->capture_substream
= NULL
;
1190 snd_opti93x_close(chip
, OPTi93X_MODE_CAPTURE
);
1195 static void snd_opti93x_init(struct snd_opti93x
*chip
)
1197 unsigned long flags
;
1200 spin_lock_irqsave(&chip
->lock
, flags
);
1201 snd_opti93x_mce_up(chip
);
1203 for (i
= 0; i
< 32; i
++)
1204 snd_opti93x_out_image(chip
, i
, snd_opti93x_default_image
[i
]);
1206 snd_opti93x_mce_down(chip
);
1207 spin_unlock_irqrestore(&chip
->lock
, flags
);
1210 static int snd_opti93x_probe(struct snd_opti93x
*chip
)
1212 unsigned long flags
;
1215 spin_lock_irqsave(&chip
->lock
, flags
);
1216 val
= snd_opti93x_in(chip
, OPTi93X_ID
) & 0x0f;
1217 spin_unlock_irqrestore(&chip
->lock
, flags
);
1219 return (val
== 0x0a) ? 0 : -ENODEV
;
1222 static int snd_opti93x_free(struct snd_opti93x
*chip
)
1224 release_and_free_resource(chip
->res_port
);
1225 if (chip
->dma1
>= 0) {
1226 disable_dma(chip
->dma1
);
1227 free_dma(chip
->dma1
);
1229 if (chip
->dma2
>= 0) {
1230 disable_dma(chip
->dma2
);
1231 free_dma(chip
->dma2
);
1233 if (chip
->irq
>= 0) {
1234 free_irq(chip
->irq
, chip
);
1240 static int snd_opti93x_dev_free(struct snd_device
*device
)
1242 struct snd_opti93x
*chip
= device
->device_data
;
1243 return snd_opti93x_free(chip
);
1246 static const char *snd_opti93x_chip_id(struct snd_opti93x
*codec
)
1248 switch (codec
->hardware
) {
1249 case OPTi9XX_HW_82C930
: return "82C930";
1250 case OPTi9XX_HW_82C931
: return "82C931";
1251 case OPTi9XX_HW_82C933
: return "82C933";
1252 default: return "???";
1256 static int snd_opti93x_create(struct snd_card
*card
, struct snd_opti9xx
*chip
,
1258 struct snd_opti93x
**rcodec
)
1260 static struct snd_device_ops ops
= {
1261 .dev_free
= snd_opti93x_dev_free
,
1264 struct snd_opti93x
*codec
;
1267 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
1274 if ((codec
->res_port
= request_region(chip
->wss_base
+ 4, 4, "OPTI93x CODEC")) == NULL
) {
1275 snd_printk(KERN_ERR
"opti9xx: can't grab port 0x%lx\n", chip
->wss_base
+ 4);
1276 snd_opti93x_free(codec
);
1279 if (request_dma(dma1
, "OPTI93x - 1")) {
1280 snd_printk(KERN_ERR
"opti9xx: can't grab DMA1 %d\n", dma1
);
1281 snd_opti93x_free(codec
);
1284 codec
->dma1
= chip
->dma1
;
1285 if (request_dma(dma2
, "OPTI93x - 2")) {
1286 snd_printk(KERN_ERR
"opti9xx: can't grab DMA2 %d\n", dma2
);
1287 snd_opti93x_free(codec
);
1290 codec
->dma2
= chip
->dma2
;
1292 if (request_irq(chip
->irq
, snd_opti93x_interrupt
, IRQF_DISABLED
, DEV_NAME
" - WSS", codec
)) {
1293 snd_printk(KERN_ERR
"opti9xx: can't grab IRQ %d\n", chip
->irq
);
1294 snd_opti93x_free(codec
);
1299 codec
->port
= chip
->wss_base
+ 4;
1300 codec
->irq
= chip
->irq
;
1302 spin_lock_init(&codec
->lock
);
1303 codec
->hardware
= chip
->hardware
;
1306 if ((error
= snd_opti93x_probe(codec
))) {
1307 snd_opti93x_free(codec
);
1311 snd_opti93x_init(codec
);
1313 /* Register device */
1314 if ((error
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, codec
, &ops
)) < 0) {
1315 snd_opti93x_free(codec
);
1323 static struct snd_pcm_ops snd_opti93x_playback_ops
= {
1324 .open
= snd_opti93x_playback_open
,
1325 .close
= snd_opti93x_playback_close
,
1326 .ioctl
= snd_pcm_lib_ioctl
,
1327 .hw_params
= snd_opti93x_hw_params
,
1328 .hw_free
= snd_opti93x_hw_free
,
1329 .prepare
= snd_opti93x_playback_prepare
,
1330 .trigger
= snd_opti93x_playback_trigger
,
1331 .pointer
= snd_opti93x_playback_pointer
,
1334 static struct snd_pcm_ops snd_opti93x_capture_ops
= {
1335 .open
= snd_opti93x_capture_open
,
1336 .close
= snd_opti93x_capture_close
,
1337 .ioctl
= snd_pcm_lib_ioctl
,
1338 .hw_params
= snd_opti93x_hw_params
,
1339 .hw_free
= snd_opti93x_hw_free
,
1340 .prepare
= snd_opti93x_capture_prepare
,
1341 .trigger
= snd_opti93x_capture_trigger
,
1342 .pointer
= snd_opti93x_capture_pointer
,
1345 static int snd_opti93x_pcm(struct snd_opti93x
*codec
, int device
, struct snd_pcm
**rpcm
)
1348 struct snd_pcm
*pcm
;
1350 if ((error
= snd_pcm_new(codec
->card
, "OPTi 82C93X", device
, 1, 1, &pcm
)) < 0)
1353 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_opti93x_playback_ops
);
1354 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_opti93x_capture_ops
);
1356 pcm
->private_data
= codec
;
1357 pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
1359 strcpy(pcm
->name
, snd_opti93x_chip_id(codec
));
1361 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
1363 64*1024, codec
->dma1
> 3 || codec
->dma2
> 3 ? 128*1024 : 64*1024);
1375 static int snd_opti93x_info_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1377 static char *texts
[4] = {
1378 "Line1", "Aux", "Mic", "Mix"
1381 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1383 uinfo
->value
.enumerated
.items
= 4;
1384 if (uinfo
->value
.enumerated
.item
> 3)
1385 uinfo
->value
.enumerated
.item
= 3;
1386 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
1390 static int snd_opti93x_get_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1392 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1393 unsigned long flags
;
1395 spin_lock_irqsave(&chip
->lock
, flags
);
1396 ucontrol
->value
.enumerated
.item
[0] = (chip
->image
[OPTi93X_MIXOUT_LEFT
] & OPTi93X_MIXOUT_MIXER
) >> 6;
1397 ucontrol
->value
.enumerated
.item
[1] = (chip
->image
[OPTi93X_MIXOUT_RIGHT
] & OPTi93X_MIXOUT_MIXER
) >> 6;
1398 spin_unlock_irqrestore(&chip
->lock
, flags
);
1402 static int snd_opti93x_put_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1404 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1405 unsigned long flags
;
1406 unsigned short left
, right
;
1409 if (ucontrol
->value
.enumerated
.item
[0] > 3 ||
1410 ucontrol
->value
.enumerated
.item
[1] > 3)
1412 left
= ucontrol
->value
.enumerated
.item
[0] << 6;
1413 right
= ucontrol
->value
.enumerated
.item
[1] << 6;
1414 spin_lock_irqsave(&chip
->lock
, flags
);
1415 left
= (chip
->image
[OPTi93X_MIXOUT_LEFT
] & ~OPTi93X_MIXOUT_MIXER
) | left
;
1416 right
= (chip
->image
[OPTi93X_MIXOUT_RIGHT
] & ~OPTi93X_MIXOUT_MIXER
) | right
;
1417 change
= left
!= chip
->image
[OPTi93X_MIXOUT_LEFT
] ||
1418 right
!= chip
->image
[OPTi93X_MIXOUT_RIGHT
];
1419 snd_opti93x_out_image(chip
, OPTi93X_MIXOUT_LEFT
, left
);
1420 snd_opti93x_out_image(chip
, OPTi93X_MIXOUT_RIGHT
, right
);
1421 spin_unlock_irqrestore(&chip
->lock
, flags
);
1427 #define OPTi93X_SINGLE(xname, xindex, reg, shift, mask, invert) \
1428 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1429 .info = snd_opti93x_info_single, \
1430 .get = snd_opti93x_get_single, .put = snd_opti93x_put_single, \
1431 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1433 static int snd_opti93x_info_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1435 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1437 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1439 uinfo
->value
.integer
.min
= 0;
1440 uinfo
->value
.integer
.max
= mask
;
1444 static int snd_opti93x_get_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1446 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1447 unsigned long flags
;
1448 int reg
= kcontrol
->private_value
& 0xff;
1449 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1450 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1451 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
1453 spin_lock_irqsave(&chip
->lock
, flags
);
1454 ucontrol
->value
.integer
.value
[0] = (chip
->image
[reg
] >> shift
) & mask
;
1455 spin_unlock_irqrestore(&chip
->lock
, flags
);
1457 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1461 static int snd_opti93x_put_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1463 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1464 unsigned long flags
;
1465 int reg
= kcontrol
->private_value
& 0xff;
1466 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1467 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1468 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
1472 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
1476 spin_lock_irqsave(&chip
->lock
, flags
);
1477 val
= (chip
->image
[reg
] & ~(mask
<< shift
)) | val
;
1478 change
= val
!= chip
->image
[reg
];
1479 snd_opti93x_out(chip
, reg
, val
);
1480 spin_unlock_irqrestore(&chip
->lock
, flags
);
1486 #define OPTi93X_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1487 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1488 .info = snd_opti93x_info_double, \
1489 .get = snd_opti93x_get_double, .put = snd_opti93x_put_double, \
1490 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1492 #define OPTi93X_DOUBLE_INVERT_INVERT(xctl) \
1493 do { xctl.private_value ^= 22; } while (0)
1494 #define OPTi93X_DOUBLE_CHANGE_REGS(xctl, left_reg, right_reg) \
1495 do { xctl.private_value &= ~0x0000ffff; \
1496 xctl.private_value |= left_reg | (right_reg << 8); } while (0)
1498 static int snd_opti93x_info_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1500 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1502 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1504 uinfo
->value
.integer
.min
= 0;
1505 uinfo
->value
.integer
.max
= mask
;
1509 static int snd_opti93x_get_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1511 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1512 unsigned long flags
;
1513 int left_reg
= kcontrol
->private_value
& 0xff;
1514 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1515 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1516 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1517 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1518 int invert
= (kcontrol
->private_value
>> 22) & 1;
1520 spin_lock_irqsave(&chip
->lock
, flags
);
1521 ucontrol
->value
.integer
.value
[0] = (chip
->image
[left_reg
] >> shift_left
) & mask
;
1522 ucontrol
->value
.integer
.value
[1] = (chip
->image
[right_reg
] >> shift_right
) & mask
;
1523 spin_unlock_irqrestore(&chip
->lock
, flags
);
1525 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1526 ucontrol
->value
.integer
.value
[1] = mask
- ucontrol
->value
.integer
.value
[1];
1531 static int snd_opti93x_put_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1533 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1534 unsigned long flags
;
1535 int left_reg
= kcontrol
->private_value
& 0xff;
1536 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1537 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1538 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1539 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1540 int invert
= (kcontrol
->private_value
>> 22) & 1;
1542 unsigned short val1
, val2
;
1544 val1
= ucontrol
->value
.integer
.value
[0] & mask
;
1545 val2
= ucontrol
->value
.integer
.value
[1] & mask
;
1550 val1
<<= shift_left
;
1551 val2
<<= shift_right
;
1552 spin_lock_irqsave(&chip
->lock
, flags
);
1553 val1
= (chip
->image
[left_reg
] & ~(mask
<< shift_left
)) | val1
;
1554 val2
= (chip
->image
[right_reg
] & ~(mask
<< shift_right
)) | val2
;
1555 change
= val1
!= chip
->image
[left_reg
] || val2
!= chip
->image
[right_reg
];
1556 snd_opti93x_out_image(chip
, left_reg
, val1
);
1557 snd_opti93x_out_image(chip
, right_reg
, val2
);
1558 spin_unlock_irqrestore(&chip
->lock
, flags
);
1562 static struct snd_kcontrol_new snd_opti93x_controls
[] __devinitdata
= {
1563 OPTi93X_DOUBLE("Master Playback Switch", 0, OPTi93X_OUT_LEFT
, OPTi93X_OUT_RIGHT
, 7, 7, 1, 1),
1564 OPTi93X_DOUBLE("Master Playback Volume", 0, OPTi93X_OUT_LEFT
, OPTi93X_OUT_RIGHT
, 1, 1, 31, 1),
1565 OPTi93X_DOUBLE("PCM Playback Switch", 0, OPTi93X_DAC_LEFT
, OPTi93X_DAC_RIGHT
, 7, 7, 1, 1),
1566 OPTi93X_DOUBLE("PCM Playback Volume", 0, OPTi93X_DAC_LEFT
, OPTi93X_DAC_RIGHT
, 0, 0, 31, 1),
1567 OPTi93X_DOUBLE("FM Playback Switch", 0, OPTi931_FM_LEFT_INPUT
, OPTi931_FM_RIGHT_INPUT
, 7, 7, 1, 1),
1568 OPTi93X_DOUBLE("FM Playback Volume", 0, OPTi931_FM_LEFT_INPUT
, OPTi931_FM_RIGHT_INPUT
, 1, 1, 15, 1),
1569 OPTi93X_DOUBLE("Line Playback Switch", 0, OPTi93X_LINE_LEFT_INPUT
, OPTi93X_LINE_RIGHT_INPUT
, 7, 7, 1, 1),
1570 OPTi93X_DOUBLE("Line Playback Volume", 0, OPTi93X_LINE_LEFT_INPUT
, OPTi93X_LINE_RIGHT_INPUT
, 1, 1, 15, 1),
1571 OPTi93X_DOUBLE("Mic Playback Switch", 0, OPTi93X_MIC_LEFT_INPUT
, OPTi93X_MIC_RIGHT_INPUT
, 7, 7, 1, 1),
1572 OPTi93X_DOUBLE("Mic Playback Volume", 0, OPTi93X_MIC_LEFT_INPUT
, OPTi93X_MIC_RIGHT_INPUT
, 1, 1, 15, 1),
1573 OPTi93X_DOUBLE("Mic Boost", 0, OPTi93X_MIXOUT_LEFT
, OPTi93X_MIXOUT_RIGHT
, 5, 5, 1, 1),
1574 OPTi93X_DOUBLE("CD Playback Switch", 0, OPTi93X_CD_LEFT_INPUT
, OPTi93X_CD_RIGHT_INPUT
, 7, 7, 1, 1),
1575 OPTi93X_DOUBLE("CD Playback Volume", 0, OPTi93X_CD_LEFT_INPUT
, OPTi93X_CD_RIGHT_INPUT
, 1, 1, 15, 1),
1576 OPTi93X_DOUBLE("Aux Playback Switch", 0, OPTi931_AUX_LEFT_INPUT
, OPTi931_AUX_RIGHT_INPUT
, 7, 7, 1, 1),
1577 OPTi93X_DOUBLE("Aux Playback Volume", 0, OPTi931_AUX_LEFT_INPUT
, OPTi931_AUX_RIGHT_INPUT
, 1, 1, 15, 1),
1578 OPTi93X_DOUBLE("Capture Volume", 0, OPTi93X_MIXOUT_LEFT
, OPTi93X_MIXOUT_RIGHT
, 0, 0, 15, 0),
1580 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1581 .name
= "Capture Source",
1582 .info
= snd_opti93x_info_mux
,
1583 .get
= snd_opti93x_get_mux
,
1584 .put
= snd_opti93x_put_mux
,
1588 static int snd_opti93x_mixer(struct snd_opti93x
*chip
)
1590 struct snd_card
*card
;
1591 struct snd_kcontrol_new knew
;
1595 snd_assert(chip
!= NULL
&& chip
->card
!= NULL
, return -EINVAL
);
1599 strcpy(card
->mixername
, snd_opti93x_chip_id(chip
));
1601 for (idx
= 0; idx
< ARRAY_SIZE(snd_opti93x_controls
); idx
++) {
1602 knew
= snd_opti93x_controls
[idx
];
1603 if (chip
->hardware
== OPTi9XX_HW_82C930
) {
1604 if (strstr(knew
.name
, "FM")) /* skip FM controls */
1606 else if (strcmp(knew
.name
, "Mic Playback Volume"))
1607 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1608 else if (strstr(knew
.name
, "Aux"))
1609 OPTi93X_DOUBLE_CHANGE_REGS(knew
, OPTi930_AUX_LEFT_INPUT
, OPTi930_AUX_RIGHT_INPUT
);
1610 else if (strcmp(knew
.name
, "PCM Playback Volume"))
1611 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1612 else if (strcmp(knew
.name
, "Master Playback Volume"))
1613 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1615 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_opti93x_controls
[idx
], chip
))) < 0)
1621 #endif /* OPTi93X */
1623 static int __devinit
snd_card_opti9xx_detect(struct snd_card
*card
,
1624 struct snd_opti9xx
*chip
)
1629 for (i
= OPTi9XX_HW_82C928
; i
< OPTi9XX_HW_82C930
; i
++) {
1630 unsigned char value
;
1632 if ((err
= snd_opti9xx_init(chip
, i
)) < 0)
1635 if ((chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
)
1638 value
= snd_opti9xx_read(chip
, OPTi9XX_MC_REG(1));
1639 if ((value
!= 0xff) && (value
!= inb(chip
->mc_base
+ 1)))
1640 if (value
== snd_opti9xx_read(chip
, OPTi9XX_MC_REG(1)))
1643 release_and_free_resource(chip
->res_mc_base
);
1644 chip
->res_mc_base
= NULL
;
1648 for (i
= OPTi9XX_HW_82C931
; i
>= OPTi9XX_HW_82C930
; i
--) {
1649 unsigned long flags
;
1650 unsigned char value
;
1652 if ((err
= snd_opti9xx_init(chip
, i
)) < 0)
1655 if ((chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
)
1658 spin_lock_irqsave(&chip
->lock
, flags
);
1659 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
1660 outb(((chip
->mc_indir_index
& (1 << 8)) >> 4) |
1661 ((chip
->mc_indir_index
& 0xf0) >> 4), chip
->mc_base
);
1662 spin_unlock_irqrestore(&chip
->lock
, flags
);
1664 value
= snd_opti9xx_read(chip
, OPTi9XX_MC_REG(7));
1665 snd_opti9xx_write(chip
, OPTi9XX_MC_REG(7), 0xff - value
);
1666 if (snd_opti9xx_read(chip
, OPTi9XX_MC_REG(7)) == 0xff - value
)
1669 release_and_free_resource(chip
->res_mc_base
);
1670 chip
->res_mc_base
= NULL
;
1672 #endif /* OPTi93X */
1678 static int __devinit
snd_card_opti9xx_pnp(struct snd_opti9xx
*chip
,
1679 struct pnp_card_link
*card
,
1680 const struct pnp_card_device_id
*pid
)
1682 struct pnp_dev
*pdev
;
1683 struct pnp_resource_table
*cfg
= kmalloc(sizeof(*cfg
), GFP_KERNEL
);
1688 chip
->dev
= pnp_request_card_device(card
, pid
->devs
[0].id
, NULL
);
1689 if (chip
->dev
== NULL
) {
1693 chip
->devmpu
= pnp_request_card_device(card
, pid
->devs
[1].id
, NULL
);
1696 pnp_init_resource_table(cfg
);
1699 if (port
!= SNDRV_AUTO_PORT
)
1700 pnp_resource_change(&cfg
->port_resource
[0], port
+ 4, 4);
1702 if (pid
->driver_data
!= 0x0924 && port
!= SNDRV_AUTO_PORT
)
1703 pnp_resource_change(&cfg
->port_resource
[1], port
, 4);
1704 #endif /* OPTi93X */
1705 if (irq
!= SNDRV_AUTO_IRQ
)
1706 pnp_resource_change(&cfg
->irq_resource
[0], irq
, 1);
1707 if (dma1
!= SNDRV_AUTO_DMA
)
1708 pnp_resource_change(&cfg
->dma_resource
[0], dma1
, 1);
1709 #if defined(CS4231) || defined(OPTi93X)
1710 if (dma2
!= SNDRV_AUTO_DMA
)
1711 pnp_resource_change(&cfg
->dma_resource
[1], dma2
, 1);
1713 #ifdef snd_opti9xx_fixup_dma2
1714 snd_opti9xx_fixup_dma2(pdev
);
1716 #endif /* CS4231 || OPTi93X */
1718 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
)
1719 pnp_resource_change(&cfg
->port_resource
[1], fm_port
, 4);
1721 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
)
1722 pnp_resource_change(&cfg
->port_resource
[2], fm_port
, 4);
1724 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
1725 snd_printk(KERN_ERR
"AUDIO the requested resources are invalid, using auto config\n");
1726 err
= pnp_activate_dev(pdev
);
1728 snd_printk(KERN_ERR
"AUDIO pnp configure failure: %d\n", err
);
1734 port
= pnp_port_start(pdev
, 0) - 4;
1735 fm_port
= pnp_port_start(pdev
, 1) + 8;
1737 if (pid
->driver_data
!= 0x0924)
1738 port
= pnp_port_start(pdev
, 1);
1739 fm_port
= pnp_port_start(pdev
, 2) + 8;
1740 #endif /* OPTi93X */
1741 irq
= pnp_irq(pdev
, 0);
1742 dma1
= pnp_dma(pdev
, 0);
1743 #if defined(CS4231) || defined(OPTi93X)
1744 dma2
= pnp_dma(pdev
, 1);
1745 #endif /* CS4231 || OPTi93X */
1747 pdev
= chip
->devmpu
;
1748 if (pdev
&& mpu_port
> 0) {
1749 pnp_init_resource_table(cfg
);
1751 if (mpu_port
!= SNDRV_AUTO_PORT
)
1752 pnp_resource_change(&cfg
->port_resource
[0], mpu_port
, 2);
1753 if (mpu_irq
!= SNDRV_AUTO_IRQ
)
1754 pnp_resource_change(&cfg
->irq_resource
[0], mpu_irq
, 1);
1756 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
1757 snd_printk(KERN_ERR
"AUDIO the requested resources are invalid, using auto config\n");
1758 err
= pnp_activate_dev(pdev
);
1760 snd_printk(KERN_ERR
"AUDIO pnp configure failure\n");
1762 chip
->devmpu
= NULL
;
1764 mpu_port
= pnp_port_start(pdev
, 0);
1765 mpu_irq
= pnp_irq(pdev
, 0);
1769 return pid
->driver_data
;
1771 #endif /* CONFIG_PNP */
1773 static void snd_card_opti9xx_free(struct snd_card
*card
)
1775 struct snd_opti9xx
*chip
= card
->private_data
;
1778 release_and_free_resource(chip
->res_mc_base
);
1781 static int __devinit
snd_opti9xx_probe(struct snd_card
*card
)
1783 static long possible_ports
[] = {0x530, 0xe80, 0xf40, 0x604, -1};
1785 struct snd_opti9xx
*chip
= card
->private_data
;
1786 #if defined(OPTi93X)
1787 struct snd_opti93x
*codec
;
1788 #elif defined(CS4231)
1789 struct snd_cs4231
*codec
;
1790 struct snd_timer
*timer
;
1792 struct snd_ad1848
*codec
;
1794 struct snd_pcm
*pcm
;
1795 struct snd_rawmidi
*rmidi
;
1796 struct snd_hwdep
*synth
;
1798 if (! chip
->res_mc_base
&&
1799 (chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
,
1800 "OPTi9xx MC")) == NULL
)
1803 chip
->wss_base
= port
;
1804 chip
->fm_port
= fm_port
;
1805 chip
->mpu_port
= mpu_port
;
1807 chip
->mpu_irq
= mpu_irq
;
1809 #if defined(CS4231) || defined(OPTi93X)
1813 if (chip
->wss_base
== SNDRV_AUTO_PORT
) {
1814 if ((chip
->wss_base
= snd_legacy_find_free_ioport(possible_ports
, 4)) < 0) {
1815 snd_printk("unable to find a free WSS port\n");
1819 if ((error
= snd_opti9xx_configure(chip
)))
1822 #if defined(OPTi93X)
1823 if ((error
= snd_opti93x_create(card
, chip
, chip
->dma1
, chip
->dma2
, &codec
)))
1825 if ((error
= snd_opti93x_pcm(codec
, 0, &pcm
)) < 0)
1827 if ((error
= snd_opti93x_mixer(codec
)) < 0)
1829 #elif defined(CS4231)
1830 if ((error
= snd_cs4231_create(card
, chip
->wss_base
+ 4, -1,
1831 chip
->irq
, chip
->dma1
, chip
->dma2
,
1836 if ((error
= snd_cs4231_pcm(codec
, 0, &pcm
)) < 0)
1838 if ((error
= snd_cs4231_mixer(codec
)) < 0)
1840 if ((error
= snd_cs4231_timer(codec
, 0, &timer
)) < 0)
1843 if ((error
= snd_ad1848_create(card
, chip
->wss_base
+ 4,
1844 chip
->irq
, chip
->dma1
,
1845 AD1848_HW_DETECT
, &codec
)) < 0)
1847 if ((error
= snd_ad1848_pcm(codec
, 0, &pcm
)) < 0)
1849 if ((error
= snd_ad1848_mixer(codec
)) < 0)
1852 strcpy(card
->driver
, chip
->name
);
1853 sprintf(card
->shortname
, "OPTi %s", card
->driver
);
1854 #if defined(CS4231) || defined(OPTi93X)
1855 sprintf(card
->longname
, "%s, %s at 0x%lx, irq %d, dma %d&%d",
1856 card
->shortname
, pcm
->name
, chip
->wss_base
+ 4,
1857 chip
->irq
, chip
->dma1
, chip
->dma2
);
1859 sprintf(card
->longname
, "%s, %s at 0x%lx, irq %d, dma %d",
1860 card
->shortname
, pcm
->name
, chip
->wss_base
+ 4,
1861 chip
->irq
, chip
->dma1
);
1862 #endif /* CS4231 || OPTi93X */
1864 if (chip
->mpu_port
<= 0 || chip
->mpu_port
== SNDRV_AUTO_PORT
)
1867 if ((error
= snd_mpu401_uart_new(card
, 0, MPU401_HW_MPU401
,
1868 chip
->mpu_port
, 0, chip
->mpu_irq
, IRQF_DISABLED
,
1870 snd_printk(KERN_WARNING
"no MPU-401 device at 0x%lx?\n",
1873 if (chip
->fm_port
> 0 && chip
->fm_port
!= SNDRV_AUTO_PORT
) {
1874 struct snd_opl3
*opl3
= NULL
;
1876 if (chip
->hardware
== OPTi9XX_HW_82C928
||
1877 chip
->hardware
== OPTi9XX_HW_82C929
||
1878 chip
->hardware
== OPTi9XX_HW_82C924
) {
1879 struct snd_opl4
*opl4
;
1880 /* assume we have an OPL4 */
1881 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2),
1883 if (snd_opl4_create(card
,
1886 2, &opl3
, &opl4
) < 0) {
1887 /* no luck, use OPL3 instead */
1888 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2),
1892 #endif /* !OPTi93X */
1893 if (!opl3
&& snd_opl3_create(card
,
1896 OPL3_HW_AUTO
, 0, &opl3
) < 0) {
1897 snd_printk(KERN_WARNING
"no OPL device at 0x%lx-0x%lx\n",
1898 chip
->fm_port
, chip
->fm_port
+ 4 - 1);
1902 const int t1dev
= 1;
1904 const int t1dev
= 0;
1906 if ((error
= snd_opl3_timer_new(opl3
, t1dev
, t1dev
+1)) < 0)
1908 if ((error
= snd_opl3_hwdep_new(opl3
, 0, 1, &synth
)) < 0)
1913 return snd_card_register(card
);
1916 static struct snd_card
*snd_opti9xx_card_new(void)
1918 struct snd_card
*card
;
1920 card
= snd_card_new(index
, id
, THIS_MODULE
, sizeof(struct snd_opti9xx
));
1923 card
->private_free
= snd_card_opti9xx_free
;
1927 static int __devinit
snd_opti9xx_isa_match(struct device
*devptr
,
1931 if (snd_opti9xx_pnp_is_probed
)
1939 static int __devinit
snd_opti9xx_isa_probe(struct device
*devptr
,
1942 struct snd_card
*card
;
1944 static long possible_mpu_ports
[] = {0x300, 0x310, 0x320, 0x330, -1};
1946 static int possible_irqs
[] = {5, 9, 10, 11, 7, -1};
1948 static int possible_irqs
[] = {9, 10, 11, 7, -1};
1949 #endif /* OPTi93X */
1950 static int possible_mpu_irqs
[] = {5, 9, 10, 7, -1};
1951 static int possible_dma1s
[] = {3, 1, 0, -1};
1952 #if defined(CS4231) || defined(OPTi93X)
1953 static int possible_dma2s
[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}};
1954 #endif /* CS4231 || OPTi93X */
1956 if (mpu_port
== SNDRV_AUTO_PORT
) {
1957 if ((mpu_port
= snd_legacy_find_free_ioport(possible_mpu_ports
, 2)) < 0) {
1958 snd_printk(KERN_ERR
"unable to find a free MPU401 port\n");
1962 if (irq
== SNDRV_AUTO_IRQ
) {
1963 if ((irq
= snd_legacy_find_free_irq(possible_irqs
)) < 0) {
1964 snd_printk(KERN_ERR
"unable to find a free IRQ\n");
1968 if (mpu_irq
== SNDRV_AUTO_IRQ
) {
1969 if ((mpu_irq
= snd_legacy_find_free_irq(possible_mpu_irqs
)) < 0) {
1970 snd_printk(KERN_ERR
"unable to find a free MPU401 IRQ\n");
1974 if (dma1
== SNDRV_AUTO_DMA
) {
1975 if ((dma1
= snd_legacy_find_free_dma(possible_dma1s
)) < 0) {
1976 snd_printk(KERN_ERR
"unable to find a free DMA1\n");
1980 #if defined(CS4231) || defined(OPTi93X)
1981 if (dma2
== SNDRV_AUTO_DMA
) {
1982 if ((dma2
= snd_legacy_find_free_dma(possible_dma2s
[dma1
% 4])) < 0) {
1983 snd_printk("unable to find a free DMA2\n");
1989 card
= snd_opti9xx_card_new();
1993 if ((error
= snd_card_opti9xx_detect(card
, card
->private_data
)) < 0) {
1994 snd_card_free(card
);
1997 snd_card_set_dev(card
, devptr
);
1998 if ((error
= snd_opti9xx_probe(card
)) < 0) {
1999 snd_card_free(card
);
2002 dev_set_drvdata(devptr
, card
);
2006 static int __devexit
snd_opti9xx_isa_remove(struct device
*devptr
,
2009 snd_card_free(dev_get_drvdata(devptr
));
2010 dev_set_drvdata(devptr
, NULL
);
2014 static struct isa_driver snd_opti9xx_driver
= {
2015 .match
= snd_opti9xx_isa_match
,
2016 .probe
= snd_opti9xx_isa_probe
,
2017 .remove
= __devexit_p(snd_opti9xx_isa_remove
),
2018 /* FIXME: suspend/resume */
2025 static int __devinit
snd_opti9xx_pnp_probe(struct pnp_card_link
*pcard
,
2026 const struct pnp_card_device_id
*pid
)
2028 struct snd_card
*card
;
2030 struct snd_opti9xx
*chip
;
2032 if (snd_opti9xx_pnp_is_probed
)
2036 card
= snd_opti9xx_card_new();
2039 chip
= card
->private_data
;
2041 hw
= snd_card_opti9xx_pnp(chip
, pcard
, pid
);
2044 hw
= OPTi9XX_HW_82C924
;
2047 hw
= OPTi9XX_HW_82C925
;
2050 hw
= OPTi9XX_HW_82C931
;
2053 snd_card_free(card
);
2057 if ((error
= snd_opti9xx_init(chip
, hw
))) {
2058 snd_card_free(card
);
2061 if (hw
<= OPTi9XX_HW_82C930
)
2062 chip
->mc_base
-= 0x80;
2063 snd_card_set_dev(card
, &pcard
->card
->dev
);
2064 if ((error
= snd_opti9xx_probe(card
)) < 0) {
2065 snd_card_free(card
);
2068 pnp_set_card_drvdata(pcard
, card
);
2069 snd_opti9xx_pnp_is_probed
= 1;
2073 static void __devexit
snd_opti9xx_pnp_remove(struct pnp_card_link
* pcard
)
2075 snd_card_free(pnp_get_card_drvdata(pcard
));
2076 pnp_set_card_drvdata(pcard
, NULL
);
2077 snd_opti9xx_pnp_is_probed
= 0;
2080 static struct pnp_card_driver opti9xx_pnpc_driver
= {
2081 .flags
= PNP_DRIVER_RES_DISABLE
,
2083 .id_table
= snd_opti9xx_pnpids
,
2084 .probe
= snd_opti9xx_pnp_probe
,
2085 .remove
= __devexit_p(snd_opti9xx_pnp_remove
),
2090 #define CHIP_NAME "82C93x"
2092 #define CHIP_NAME "82C92x"
2095 static int __init
alsa_card_opti9xx_init(void)
2098 pnp_register_card_driver(&opti9xx_pnpc_driver
);
2099 if (snd_opti9xx_pnp_is_probed
)
2101 pnp_unregister_card_driver(&opti9xx_pnpc_driver
);
2103 return isa_register_driver(&snd_opti9xx_driver
, 1);
2106 static void __exit
alsa_card_opti9xx_exit(void)
2108 if (!snd_opti9xx_pnp_is_probed
) {
2109 isa_unregister_driver(&snd_opti9xx_driver
);
2113 pnp_unregister_card_driver(&opti9xx_pnpc_driver
);
2117 module_init(alsa_card_opti9xx_init
)
2118 module_exit(alsa_card_opti9xx_exit
)