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