[PATCH] Last DMA_xBIT_MASK cleanups
[linux-2.6.git] / sound / pci / als300.c
1 /*
2  *  als300.c - driver for Avance Logic ALS300/ALS300+ soundcards.
3  *  Copyright (C) 2005 by Ash Willis <ashwillis@programmer.net>
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2 of the License, or
8  *  (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18  *
19  *  TODO
20  *  4 channel playback for ALS300+
21  *  gameport
22  *  mpu401
23  *  opl3
24  *
25  *  NOTES
26  *  The BLOCK_COUNTER registers for the ALS300(+) return a figure related to
27  *  the position in the current period, NOT the whole buffer. It is important
28  *  to know which period we are in so we can calculate the correct pointer.
29  *  This is why we always use 2 periods. We can then use a flip-flop variable
30  *  to keep track of what period we are in.
31  */
32
33 #include <sound/driver.h>
34 #include <linux/delay.h>
35 #include <linux/init.h>
36 #include <linux/moduleparam.h>
37 #include <linux/pci.h>
38 #include <linux/dma-mapping.h>
39 #include <linux/interrupt.h>
40 #include <linux/slab.h>
41
42 #include <asm/io.h>
43
44 #include <sound/core.h>
45 #include <sound/control.h>
46 #include <sound/initval.h>
47 #include <sound/pcm.h>
48 #include <sound/pcm_params.h>
49 #include <sound/ac97_codec.h>
50 #include <sound/opl3.h>
51
52 /* snd_als300_set_irq_flag */
53 #define IRQ_DISABLE             0
54 #define IRQ_ENABLE              1
55
56 /* I/O port layout */
57 #define AC97_ACCESS             0x00
58 #define AC97_READ               0x04
59 #define AC97_STATUS             0x06
60 #define   AC97_DATA_AVAIL               (1<<6)
61 #define   AC97_BUSY                     (1<<7)
62 #define ALS300_IRQ_STATUS       0x07            /* ALS300 Only */
63 #define   IRQ_PLAYBACK                  (1<<3)
64 #define   IRQ_CAPTURE                   (1<<2)
65 #define GCR_DATA                0x08
66 #define GCR_INDEX               0x0C
67 #define ALS300P_DRAM_IRQ_STATUS 0x0D            /* ALS300+ Only */
68 #define MPU_IRQ_STATUS          0x0E            /* ALS300 Rev. E+, ALS300+ */
69 #define ALS300P_IRQ_STATUS      0x0F            /* ALS300+ Only */
70
71 /* General Control Registers */
72 #define PLAYBACK_START          0x80
73 #define PLAYBACK_END            0x81
74 #define PLAYBACK_CONTROL        0x82
75 #define   TRANSFER_START                (1<<16)
76 #define   FIFO_PAUSE                    (1<<17)
77 #define RECORD_START            0x83
78 #define RECORD_END              0x84
79 #define RECORD_CONTROL          0x85
80 #define DRAM_WRITE_CONTROL      0x8B
81 #define   WRITE_TRANS_START             (1<<16)
82 #define   DRAM_MODE_2                   (1<<17)
83 #define MISC_CONTROL            0x8C
84 #define   IRQ_SET_BIT                   (1<<15)
85 #define   VMUTE_NORMAL                  (1<<20)
86 #define   MMUTE_NORMAL                  (1<<21)
87 #define MUS_VOC_VOL             0x8E
88 #define PLAYBACK_BLOCK_COUNTER  0x9A
89 #define RECORD_BLOCK_COUNTER    0x9B
90
91 #define DEBUG_CALLS     1
92 #define DEBUG_PLAY_REC  1
93
94 #if DEBUG_CALLS
95 #define snd_als300_dbgcalls(format, args...) printk(format, ##args)
96 #define snd_als300_dbgcallenter() printk(KERN_ERR "--> %s\n", __FUNCTION__)
97 #define snd_als300_dbgcallleave() printk(KERN_ERR "<-- %s\n", __FUNCTION__)
98 #else
99 #define snd_als300_dbgcalls(format, args...)
100 #define snd_als300_dbgcallenter()
101 #define snd_als300_dbgcallleave()
102 #endif
103
104 #if DEBUG_PLAY_REC
105 #define snd_als300_dbgplay(format, args...) printk(KERN_ERR format, ##args)
106 #else
107 #define snd_als300_dbgplay(format, args...)
108 #endif          
109
110 enum {DEVICE_ALS300, DEVICE_ALS300_PLUS};
111
112 MODULE_AUTHOR("Ash Willis <ashwillis@programmer.net>");
113 MODULE_DESCRIPTION("Avance Logic ALS300");
114 MODULE_LICENSE("GPL");
115 MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS300},{Avance Logic,ALS300+}}");
116
117 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
118 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
119 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
120
121 struct snd_als300 {
122         unsigned long port;
123         spinlock_t reg_lock;
124         struct snd_card *card;
125         struct pci_dev *pci;
126
127         struct snd_pcm *pcm;
128         struct snd_pcm_substream *playback_substream;
129         struct snd_pcm_substream *capture_substream;
130
131         struct snd_ac97 *ac97;
132         struct snd_opl3 *opl3;
133
134         struct resource *res_port;
135
136         int irq;
137
138         int chip_type; /* ALS300 or ALS300+ */
139
140         char revision;  
141 };
142
143 struct snd_als300_substream_data {
144         int period_flipflop;
145         int control_register;
146         int block_counter_register;
147 };
148
149 static struct pci_device_id snd_als300_ids[] = {
150         { 0x4005, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300 },
151         { 0x4005, 0x0308, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300_PLUS },
152         { 0, }
153 };
154
155 MODULE_DEVICE_TABLE(pci, snd_als300_ids);
156
157 static inline u32 snd_als300_gcr_read(unsigned long port, unsigned short reg)
158 {
159         outb(reg, port+GCR_INDEX);
160         return inl(port+GCR_DATA);
161 }
162
163 static inline void snd_als300_gcr_write(unsigned long port,
164                                                 unsigned short reg, u32 val)
165 {
166         outb(reg, port+GCR_INDEX);
167         outl(val, port+GCR_DATA);
168 }
169
170 /* Enable/Disable Interrupts */
171 static void snd_als300_set_irq_flag(struct snd_als300 *chip, int cmd)
172 {
173         u32 tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL);
174         snd_als300_dbgcallenter();
175
176         /* boolean XOR check, since old vs. new hardware have
177            directly reversed bit setting for ENABLE and DISABLE.
178            ALS300+ acts like newer versions of ALS300 */
179         if (((chip->revision > 5 || chip->chip_type == DEVICE_ALS300_PLUS) ^
180                                                 (cmd == IRQ_ENABLE)) == 0)
181                 tmp |= IRQ_SET_BIT;
182         else
183                 tmp &= ~IRQ_SET_BIT;
184         snd_als300_gcr_write(chip->port, MISC_CONTROL, tmp);
185         snd_als300_dbgcallleave();
186 }
187
188 static int snd_als300_free(struct snd_als300 *chip)
189 {
190         snd_als300_dbgcallenter();
191         snd_als300_set_irq_flag(chip, IRQ_DISABLE);
192         if (chip->irq >= 0)
193                 free_irq(chip->irq, (void *)chip);
194         pci_release_regions(chip->pci);
195         pci_disable_device(chip->pci);
196         kfree(chip);
197         snd_als300_dbgcallleave();
198         return 0;
199 }
200
201 static int snd_als300_dev_free(struct snd_device *device)
202 {
203         struct snd_als300 *chip = device->device_data;
204         return snd_als300_free(chip);
205 }
206
207 static irqreturn_t snd_als300_interrupt(int irq, void *dev_id,
208                                                 struct pt_regs *regs)
209 {
210         u8 status;
211         struct snd_als300 *chip = dev_id;
212         struct snd_als300_substream_data *data;
213
214         status = inb(chip->port+ALS300_IRQ_STATUS);
215         if (!status) /* shared IRQ, for different device?? Exit ASAP! */
216                 return IRQ_NONE;
217
218         /* ACK everything ASAP */
219         outb(status, chip->port+ALS300_IRQ_STATUS);
220         if (status & IRQ_PLAYBACK) {
221                 if (chip->pcm && chip->playback_substream) {
222                         data = chip->playback_substream->runtime->private_data;
223                         data->period_flipflop ^= 1;
224                         snd_pcm_period_elapsed(chip->playback_substream);
225                         snd_als300_dbgplay("IRQ_PLAYBACK\n");
226                 }
227         }
228         if (status & IRQ_CAPTURE) {
229                 if (chip->pcm && chip->capture_substream) {
230                         data = chip->capture_substream->runtime->private_data;
231                         data->period_flipflop ^= 1;
232                         snd_pcm_period_elapsed(chip->capture_substream);
233                         snd_als300_dbgplay("IRQ_CAPTURE\n");
234                 }
235         }
236         return IRQ_HANDLED;
237 }
238
239 static irqreturn_t snd_als300plus_interrupt(int irq, void *dev_id,
240                                                 struct pt_regs *regs)
241 {
242         u8 general, mpu, dram;
243         struct snd_als300 *chip = dev_id;
244         struct snd_als300_substream_data *data;
245         
246         general = inb(chip->port+ALS300P_IRQ_STATUS);
247         mpu = inb(chip->port+MPU_IRQ_STATUS);
248         dram = inb(chip->port+ALS300P_DRAM_IRQ_STATUS);
249
250         /* shared IRQ, for different device?? Exit ASAP! */
251         if ((general == 0) && ((mpu & 0x80) == 0) && ((dram & 0x01) == 0))
252                 return IRQ_NONE;
253
254         if (general & IRQ_PLAYBACK) {
255                 if (chip->pcm && chip->playback_substream) {
256                         outb(IRQ_PLAYBACK, chip->port+ALS300P_IRQ_STATUS);
257                         data = chip->playback_substream->runtime->private_data;
258                         data->period_flipflop ^= 1;
259                         snd_pcm_period_elapsed(chip->playback_substream);
260                         snd_als300_dbgplay("IRQ_PLAYBACK\n");
261                 }
262         }
263         if (general & IRQ_CAPTURE) {
264                 if (chip->pcm && chip->capture_substream) {
265                         outb(IRQ_CAPTURE, chip->port+ALS300P_IRQ_STATUS);
266                         data = chip->capture_substream->runtime->private_data;
267                         data->period_flipflop ^= 1;
268                         snd_pcm_period_elapsed(chip->capture_substream);
269                         snd_als300_dbgplay("IRQ_CAPTURE\n");
270                 }
271         }
272         /* FIXME: Ack other interrupt types. Not important right now as
273          * those other devices aren't enabled. */
274         return IRQ_HANDLED;
275 }
276
277 static void __devexit snd_als300_remove(struct pci_dev *pci)
278 {
279         snd_als300_dbgcallenter();
280         snd_card_free(pci_get_drvdata(pci));
281         pci_set_drvdata(pci, NULL);
282         snd_als300_dbgcallleave();
283 }
284
285 static unsigned short snd_als300_ac97_read(struct snd_ac97 *ac97,
286                                                         unsigned short reg)
287 {
288         int i;
289         struct snd_als300 *chip = ac97->private_data;
290
291         for (i = 0; i < 1000; i++) {
292                 if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0)
293                         break;
294                 udelay(10);
295         }
296         outl((reg << 24) | (1 << 31), chip->port+AC97_ACCESS);
297
298         for (i = 0; i < 1000; i++) {
299                 if ((inb(chip->port+AC97_STATUS) & (AC97_DATA_AVAIL)) != 0)
300                         break;
301                 udelay(10);
302         }
303         return inw(chip->port+AC97_READ);
304 }
305
306 static void snd_als300_ac97_write(struct snd_ac97 *ac97,
307                                 unsigned short reg, unsigned short val)
308 {
309         int i;
310         struct snd_als300 *chip = ac97->private_data;
311
312         for (i = 0; i < 1000; i++) {
313                 if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0)
314                         break;
315                 udelay(10);
316         }
317         outl((reg << 24) | val, chip->port+AC97_ACCESS);
318 }
319
320 static int snd_als300_ac97(struct snd_als300 *chip)
321 {
322         struct snd_ac97_bus *bus;
323         struct snd_ac97_template ac97;
324         int err;
325         static struct snd_ac97_bus_ops ops = {
326                 .write = snd_als300_ac97_write,
327                 .read = snd_als300_ac97_read,
328         };
329
330         snd_als300_dbgcallenter();
331         if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &bus)) < 0)
332                 return err;
333
334         memset(&ac97, 0, sizeof(ac97));
335         ac97.private_data = chip;
336
337         snd_als300_dbgcallleave();
338         return snd_ac97_mixer(bus, &ac97, &chip->ac97);
339 }
340
341 /* hardware definition
342  *
343  * In AC97 mode, we always use 48k/16bit/stereo.
344  * Any request to change data type is ignored by
345  * the card when it is running outside of legacy
346  * mode.
347  */
348 static struct snd_pcm_hardware snd_als300_playback_hw =
349 {
350         .info =                 (SNDRV_PCM_INFO_MMAP |
351                                 SNDRV_PCM_INFO_INTERLEAVED |
352                                 SNDRV_PCM_INFO_PAUSE |
353                                 SNDRV_PCM_INFO_MMAP_VALID),
354         .formats =              SNDRV_PCM_FMTBIT_S16,
355         .rates =                SNDRV_PCM_RATE_48000,
356         .rate_min =             48000,
357         .rate_max =             48000,
358         .channels_min =         2,
359         .channels_max =         2,
360         .buffer_bytes_max =     64 * 1024,
361         .period_bytes_min =     64,
362         .period_bytes_max =     32 * 1024,
363         .periods_min =          2,
364         .periods_max =          2,
365 };
366
367 static struct snd_pcm_hardware snd_als300_capture_hw =
368 {
369         .info =                 (SNDRV_PCM_INFO_MMAP |
370                                 SNDRV_PCM_INFO_INTERLEAVED |
371                                 SNDRV_PCM_INFO_PAUSE |
372                                 SNDRV_PCM_INFO_MMAP_VALID),
373         .formats =              SNDRV_PCM_FMTBIT_S16,
374         .rates =                SNDRV_PCM_RATE_48000,
375         .rate_min =             48000,
376         .rate_max =             48000,
377         .channels_min =         2,
378         .channels_max =         2,
379         .buffer_bytes_max =     64 * 1024,
380         .period_bytes_min =     64,
381         .period_bytes_max =     32 * 1024,
382         .periods_min =          2,
383         .periods_max =          2,
384 };
385
386 static int snd_als300_playback_open(struct snd_pcm_substream *substream)
387 {
388         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
389         struct snd_pcm_runtime *runtime = substream->runtime;
390         struct snd_als300_substream_data *data = kzalloc(sizeof(*data),
391                                                                 GFP_KERNEL);
392
393         snd_als300_dbgcallenter();
394         chip->playback_substream = substream;
395         runtime->hw = snd_als300_playback_hw;
396         runtime->private_data = data;
397         data->control_register = PLAYBACK_CONTROL;
398         data->block_counter_register = PLAYBACK_BLOCK_COUNTER;
399         snd_als300_dbgcallleave();
400         return 0;
401 }
402
403 static int snd_als300_playback_close(struct snd_pcm_substream *substream)
404 {
405         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
406         struct snd_als300_substream_data *data;
407
408         data = substream->runtime->private_data;
409         snd_als300_dbgcallenter();
410         kfree(data);
411         chip->playback_substream = NULL;
412         snd_pcm_lib_free_pages(substream);
413         snd_als300_dbgcallleave();
414         return 0;
415 }
416
417 static int snd_als300_capture_open(struct snd_pcm_substream *substream)
418 {
419         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
420         struct snd_pcm_runtime *runtime = substream->runtime;
421         struct snd_als300_substream_data *data = kzalloc(sizeof(*data),
422                                                                 GFP_KERNEL);
423
424         snd_als300_dbgcallenter();
425         chip->capture_substream = substream;
426         runtime->hw = snd_als300_capture_hw;
427         runtime->private_data = data;
428         data->control_register = RECORD_CONTROL;
429         data->block_counter_register = RECORD_BLOCK_COUNTER;
430         snd_als300_dbgcallleave();
431         return 0;
432 }
433
434 static int snd_als300_capture_close(struct snd_pcm_substream *substream)
435 {
436         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
437         struct snd_als300_substream_data *data;
438
439         data = substream->runtime->private_data;
440         snd_als300_dbgcallenter();
441         kfree(data);
442         chip->capture_substream = NULL;
443         snd_pcm_lib_free_pages(substream);
444         snd_als300_dbgcallleave();
445         return 0;
446 }
447
448 static int snd_als300_pcm_hw_params(struct snd_pcm_substream *substream,
449                                         snd_pcm_hw_params_t * hw_params)
450 {
451         return snd_pcm_lib_malloc_pages(substream,
452                                         params_buffer_bytes(hw_params));
453 }
454
455 static int snd_als300_pcm_hw_free(struct snd_pcm_substream *substream)
456 {
457         return snd_pcm_lib_free_pages(substream);
458 }
459
460 static int snd_als300_playback_prepare(struct snd_pcm_substream *substream)
461 {
462         u32 tmp;
463         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
464         struct snd_pcm_runtime *runtime = substream->runtime;
465         unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
466         unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
467         
468         snd_als300_dbgcallenter();
469         spin_lock_irq(&chip->reg_lock);
470         tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
471         tmp &= ~TRANSFER_START;
472
473         snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n",
474                                                 period_bytes, buffer_bytes);
475         
476         /* set block size */
477         tmp &= 0xffff0000;
478         tmp |= period_bytes - 1;
479         snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, tmp);
480
481         /* set dma area */
482         snd_als300_gcr_write(chip->port, PLAYBACK_START,
483                                         runtime->dma_addr);
484         snd_als300_gcr_write(chip->port, PLAYBACK_END,
485                                         runtime->dma_addr + buffer_bytes - 1);
486         spin_unlock_irq(&chip->reg_lock);
487         snd_als300_dbgcallleave();
488         return 0;
489 }
490
491 static int snd_als300_capture_prepare(struct snd_pcm_substream *substream)
492 {
493         u32 tmp;
494         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
495         struct snd_pcm_runtime *runtime = substream->runtime;
496         unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
497         unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
498
499         snd_als300_dbgcallenter();
500         spin_lock_irq(&chip->reg_lock);
501         tmp = snd_als300_gcr_read(chip->port, RECORD_CONTROL);
502         tmp &= ~TRANSFER_START;
503
504         snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", period_bytes,
505                                                         buffer_bytes);
506
507         /* set block size */
508         tmp &= 0xffff0000;
509         tmp |= period_bytes - 1;
510
511         /* set dma area */
512         snd_als300_gcr_write(chip->port, RECORD_CONTROL, tmp);
513         snd_als300_gcr_write(chip->port, RECORD_START,
514                                         runtime->dma_addr);
515         snd_als300_gcr_write(chip->port, RECORD_END,
516                                         runtime->dma_addr + buffer_bytes - 1);
517         spin_unlock_irq(&chip->reg_lock);
518         snd_als300_dbgcallleave();
519         return 0;
520 }
521
522 static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd)
523 {
524         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
525         u32 tmp;
526         struct snd_als300_substream_data *data;
527         unsigned short reg;
528         int ret = 0;
529
530         data = substream->runtime->private_data;
531         reg = data->control_register;
532
533         snd_als300_dbgcallenter();
534         spin_lock(&chip->reg_lock);
535         switch (cmd) {
536         case SNDRV_PCM_TRIGGER_START:
537         case SNDRV_PCM_TRIGGER_RESUME:
538                 tmp = snd_als300_gcr_read(chip->port, reg);
539                 data->period_flipflop = 1;
540                 snd_als300_gcr_write(chip->port, reg, tmp | TRANSFER_START);
541                 snd_als300_dbgplay("TRIGGER START\n");
542                 break;
543         case SNDRV_PCM_TRIGGER_STOP:
544         case SNDRV_PCM_TRIGGER_SUSPEND:
545                 tmp = snd_als300_gcr_read(chip->port, reg);
546                 snd_als300_gcr_write(chip->port, reg, tmp & ~TRANSFER_START);
547                 snd_als300_dbgplay("TRIGGER STOP\n");
548                 break;
549         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
550                 tmp = snd_als300_gcr_read(chip->port, reg);
551                 snd_als300_gcr_write(chip->port, reg, tmp | FIFO_PAUSE);
552                 snd_als300_dbgplay("TRIGGER PAUSE\n");
553                 break;
554         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
555                 tmp = snd_als300_gcr_read(chip->port, reg);
556                 snd_als300_gcr_write(chip->port, reg, tmp & ~FIFO_PAUSE);
557                 snd_als300_dbgplay("TRIGGER RELEASE\n");
558                 break;
559         default:
560                 snd_als300_dbgplay("TRIGGER INVALID\n");
561                 ret = -EINVAL;
562         }
563         spin_unlock(&chip->reg_lock);
564         snd_als300_dbgcallleave();
565         return ret;
566 }
567
568 static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream)
569 {
570         u16 current_ptr;
571         struct snd_als300 *chip = snd_pcm_substream_chip(substream);
572         struct snd_als300_substream_data *data;
573         unsigned short period_bytes;
574
575         data = substream->runtime->private_data;
576         period_bytes = snd_pcm_lib_period_bytes(substream);
577         
578         snd_als300_dbgcallenter();
579         spin_lock(&chip->reg_lock);
580         current_ptr = (u16) snd_als300_gcr_read(chip->port,
581                                         data->block_counter_register) + 4;
582         spin_unlock(&chip->reg_lock);
583         if (current_ptr > period_bytes)
584                 current_ptr = 0;
585         else
586                 current_ptr = period_bytes - current_ptr;
587
588         if (data->period_flipflop == 0)
589                 current_ptr += period_bytes;
590         snd_als300_dbgplay("Pointer (bytes): %d\n", current_ptr);
591         snd_als300_dbgcallleave();
592         return bytes_to_frames(substream->runtime, current_ptr);
593 }
594
595 static struct snd_pcm_ops snd_als300_playback_ops = {
596         .open =         snd_als300_playback_open,
597         .close =        snd_als300_playback_close,
598         .ioctl =        snd_pcm_lib_ioctl,
599         .hw_params =    snd_als300_pcm_hw_params,
600         .hw_free =      snd_als300_pcm_hw_free,
601         .prepare =      snd_als300_playback_prepare,
602         .trigger =      snd_als300_trigger,
603         .pointer =      snd_als300_pointer,
604 };
605
606 static struct snd_pcm_ops snd_als300_capture_ops = {
607         .open =         snd_als300_capture_open,
608         .close =        snd_als300_capture_close,
609         .ioctl =        snd_pcm_lib_ioctl,
610         .hw_params =    snd_als300_pcm_hw_params,
611         .hw_free =      snd_als300_pcm_hw_free,
612         .prepare =      snd_als300_capture_prepare,
613         .trigger =      snd_als300_trigger,
614         .pointer =      snd_als300_pointer,
615 };
616
617 static int __devinit snd_als300_new_pcm(struct snd_als300 *chip)
618 {
619         struct snd_pcm *pcm;
620         int err;
621
622         snd_als300_dbgcallenter();
623         err = snd_pcm_new(chip->card, "ALS300", 0, 1, 1, &pcm);
624         if (err < 0)
625                 return err;
626         pcm->private_data = chip;
627         strcpy(pcm->name, "ALS300");
628         chip->pcm = pcm;
629
630         /* set operators */
631         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
632                                 &snd_als300_playback_ops);
633         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
634                                 &snd_als300_capture_ops);
635
636         /* pre-allocation of buffers */
637         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
638         snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
639         snd_als300_dbgcallleave();
640         return 0;
641 }
642
643 static void snd_als300_init(struct snd_als300 *chip)
644 {
645         unsigned long flags;
646         u32 tmp;
647         
648         snd_als300_dbgcallenter();
649         spin_lock_irqsave(&chip->reg_lock, flags);
650         chip->revision = (snd_als300_gcr_read(chip->port, MISC_CONTROL) >> 16)
651                                                                 & 0x0000000F;
652         /* Setup DRAM */
653         tmp = snd_als300_gcr_read(chip->port, DRAM_WRITE_CONTROL);
654         snd_als300_gcr_write(chip->port, DRAM_WRITE_CONTROL,
655                                                 (tmp | DRAM_MODE_2)
656                                                 & ~WRITE_TRANS_START);
657
658         /* Enable IRQ output */
659         snd_als300_set_irq_flag(chip, IRQ_ENABLE);
660
661         /* Unmute hardware devices so their outputs get routed to
662          * the onboard mixer */
663         tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL);
664         snd_als300_gcr_write(chip->port, MISC_CONTROL,
665                         tmp | VMUTE_NORMAL | MMUTE_NORMAL);
666
667         /* Reset volumes */
668         snd_als300_gcr_write(chip->port, MUS_VOC_VOL, 0);
669
670         /* Make sure playback transfer is stopped */
671         tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
672         snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL,
673                         tmp & ~TRANSFER_START);
674         spin_unlock_irqrestore(&chip->reg_lock, flags);
675         snd_als300_dbgcallleave();
676 }
677
678 static int __devinit snd_als300_create(snd_card_t *card,
679                                        struct pci_dev *pci, int chip_type,
680                                        struct snd_als300 **rchip)
681 {
682         struct snd_als300 *chip;
683         void *irq_handler;
684         int err;
685
686         static snd_device_ops_t ops = {
687                 .dev_free = snd_als300_dev_free,
688         };
689         *rchip = NULL;
690
691         snd_als300_dbgcallenter();
692         if ((err = pci_enable_device(pci)) < 0)
693                 return err;
694
695         if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
696                 pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
697                 printk(KERN_ERR "error setting 28bit DMA mask\n");
698                 pci_disable_device(pci);
699                 return -ENXIO;
700         }
701         pci_set_master(pci);
702
703         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
704         if (chip == NULL) {
705                 pci_disable_device(pci);
706                 return -ENOMEM;
707         }
708
709         chip->card = card;
710         chip->pci = pci;
711         chip->irq = -1;
712         chip->chip_type = chip_type;
713         spin_lock_init(&chip->reg_lock);
714
715         if ((err = pci_request_regions(pci, "ALS300")) < 0) {
716                 kfree(chip);
717                 pci_disable_device(pci);
718                 return err;
719         }
720         chip->port = pci_resource_start(pci, 0);
721
722         if (chip->chip_type == DEVICE_ALS300_PLUS)
723                 irq_handler = snd_als300plus_interrupt;
724         else
725                 irq_handler = snd_als300_interrupt;
726
727         if (request_irq(pci->irq, irq_handler, SA_INTERRUPT|SA_SHIRQ,
728                                         card->shortname, (void *)chip)) {
729                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
730                 snd_als300_free(chip);
731                 return -EBUSY;
732         }
733         chip->irq = pci->irq;
734
735
736         snd_als300_init(chip);
737
738         if (snd_als300_ac97(chip) < 0) {
739                 snd_printk(KERN_WARNING "Could not create ac97\n");
740                 snd_als300_free(chip);
741                 return err;
742         }
743
744         if ((err = snd_als300_new_pcm(chip)) < 0) {
745                 snd_printk(KERN_WARNING "Could not create PCM\n");
746                 snd_als300_free(chip);
747                 return err;
748         }
749
750         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
751                                                 chip, &ops)) < 0) {
752                 snd_als300_free(chip);
753                 return err;
754         }
755
756         snd_card_set_dev(card, &pci->dev);
757
758         *rchip = chip;
759         snd_als300_dbgcallleave();
760         return 0;
761 }
762
763 #ifdef CONFIG_PM
764 static int snd_als300_suspend(struct pci_dev *pci, pm_message_t state)
765 {
766         struct snd_card *card = pci_get_drvdata(pci);
767         struct snd_als300 *chip = card->private_data;
768
769         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
770         snd_pcm_suspend_all(chip->pcm);
771         snd_ac97_suspend(chip->ac97);
772
773         pci_set_power_state(pci, PCI_D3hot);
774         pci_disable_device(pci);
775         pci_save_state(pci);
776         return 0;
777 }
778
779 static int snd_als300_resume(struct pci_dev *pci)
780 {
781         struct snd_card *card = pci_get_drvdata(pci);
782         struct snd_als300 *chip = card->private_data;
783
784         pci_restore_state(pci);
785         pci_enable_device(pci);
786         pci_set_power_state(pci, PCI_D0);
787         pci_set_master(pci);
788
789         snd_als300_init(chip);
790         snd_ac97_resume(chip->ac97);
791
792         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
793         return 0;
794 }
795 #endif
796
797 static int __devinit snd_als300_probe(struct pci_dev *pci,
798                              const struct pci_device_id *pci_id)
799 {
800         static int dev;
801         struct snd_card *card;
802         struct snd_als300 *chip;
803         int err, chip_type;
804
805         if (dev >= SNDRV_CARDS)
806                 return -ENODEV;
807         if (!enable[dev]) {
808                 dev++;
809                 return -ENOENT;
810         }
811
812         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
813
814         if (card == NULL)
815                 return -ENOMEM;
816
817         chip_type = pci_id->driver_data;
818
819         if ((err = snd_als300_create(card, pci, chip_type, &chip)) < 0) {
820                 snd_card_free(card);
821                 return err;
822         }
823         card->private_data = chip;
824
825         strcpy(card->driver, "ALS300");
826         if (chip->chip_type == DEVICE_ALS300_PLUS)
827                 /* don't know much about ALS300+ yet
828                  * print revision number for now */
829                 sprintf(card->shortname, "ALS300+ (Rev. %d)", chip->revision);
830         else
831                 sprintf(card->shortname, "ALS300 (Rev. %c)", 'A' +
832                                                         chip->revision - 1);
833         sprintf(card->longname, "%s at 0x%lx irq %i",
834                                 card->shortname, chip->port, chip->irq);
835
836         if ((err = snd_card_register(card)) < 0) {
837                 snd_card_free(card);
838                 return err;
839         }
840         pci_set_drvdata(pci, card);
841         dev++;
842         return 0;
843 }
844
845 static struct pci_driver driver = {
846         .name = "ALS300",
847         .id_table = snd_als300_ids,
848         .probe = snd_als300_probe,
849         .remove = __devexit_p(snd_als300_remove),
850 #ifdef CONFIG_PM
851         .suspend = snd_als300_suspend,
852         .resume = snd_als300_resume,
853 #endif
854 };
855
856 static int __init alsa_card_als300_init(void)
857 {
858         return pci_register_driver(&driver);
859 }
860
861 static void __exit alsa_card_als300_exit(void)
862 {
863         pci_unregister_driver(&driver);
864 }
865
866 module_init(alsa_card_als300_init)
867 module_exit(alsa_card_als300_exit)