projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
IRQ: Typedef the IRQ handler function type
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / pci / als300.c
CommitLineData
b3a70d5e
AW		 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>
56b146d3 38#include <linux/dma-mapping.h>
b3a70d5e
AW		 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
110enum {DEVICE_ALS300, DEVICE_ALS300_PLUS};
111
112MODULE_AUTHOR("Ash Willis <ashwillis@programmer.net>");
113MODULE_DESCRIPTION("Avance Logic ALS300");
114MODULE_LICENSE("GPL");
115MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS300},{Avance Logic,ALS300+}}");
116
117static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
118static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
119static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
120
121struct 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
143struct snd_als300_substream_data {
144 int period_flipflop;
145 int control_register;
146 int block_counter_register;
147};
148
f40b6890 149static struct pci_device_id snd_als300_ids[] = {
b3a70d5e
AW		 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
155MODULE_DEVICE_TABLE(pci, snd_als300_ids);
156
157static 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
163static 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 */
171static 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
188static 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
201static 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
207static 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
239static 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
277static 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
285static 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
306static 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
320static 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 */
348static 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
367static 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
386static 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
403static 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
417static 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
434static 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
448static 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
455static int snd_als300_pcm_hw_free(struct snd_pcm_substream *substream)
456{
457 return snd_pcm_lib_free_pages(substream);
458}
459
460static 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
491static 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
522static 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
568static 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
595static 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
606static 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
617static 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
643static 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
678static 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
56b146d3
TK		 695 if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
696 pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
b3a70d5e
AW		 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
65ca68b3 727 if (request_irq(pci->irq, irq_handler, IRQF_DISABLED|IRQF_SHARED,
b3a70d5e
AW		 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
764static 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
779static 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
797static 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
845static 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
856static int __init alsa_card_als300_init(void)
857{
858 return pci_register_driver(&driver);
859}
860
861static void __exit alsa_card_als300_exit(void)
862{
863 pci_unregister_driver(&driver);
864}
865
866module_init(alsa_card_als300_init)
867module_exit(alsa_card_als300_exit)
kernel source for telekom puls (alcatel/mediatek)