1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Driver for SiS7019 Audio Accelerator
4 *
5 * Copyright (C) 2004-2007, David Dillow
6 * Written by David Dillow <dave@thedillows.org>
7 * Inspired by the Trident 4D-WaveDX/NX driver.
8 *
9 * All rights reserved.
10 */
11
12 #include <linux/init.h>
13 #include <linux/pci.h>
14 #include <linux/time.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <linux/interrupt.h>
18 #include <linux/delay.h>
19 #include <sound/core.h>
20 #include <sound/ac97_codec.h>
21 #include <sound/initval.h>
22 #include "sis7019.h"
23
24 MODULE_AUTHOR("David Dillow <dave@thedillows.org>");
25 MODULE_DESCRIPTION("SiS7019");
26 MODULE_LICENSE("GPL");
27
28 static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
29 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
30 static bool enable = 1;
31 static int codecs = 1;
32
33 module_param(index, int, 0444);
34 MODULE_PARM_DESC(index, "Index value for SiS7019 Audio Accelerator.");
35 module_param(id, charp, 0444);
36 MODULE_PARM_DESC(id, "ID string for SiS7019 Audio Accelerator.");
37 module_param(enable, bool, 0444);
38 MODULE_PARM_DESC(enable, "Enable SiS7019 Audio Accelerator.");
39 module_param(codecs, int, 0444);
40 MODULE_PARM_DESC(codecs, "Set bit to indicate that codec number is expected to be present (default 1)");
41
42 static const struct pci_device_id snd_sis7019_ids[] = {
43 { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x7019) },
44 { 0, }
45 };
46
47 MODULE_DEVICE_TABLE(pci, snd_sis7019_ids);
48
49 /* There are three timing modes for the voices.
50 *
51 * For both playback and capture, when the buffer is one or two periods long,
52 * we use the hardware's built-in Mid-Loop Interrupt and End-Loop Interrupt
53 * to let us know when the periods have ended.
54 *
55 * When performing playback with more than two periods per buffer, we set
56 * the "Stop Sample Offset" and tell the hardware to interrupt us when we
57 * reach it. We then update the offset and continue on until we are
58 * interrupted for the next period.
59 *
60 * Capture channels do not have a SSO, so we allocate a playback channel to
61 * use as a timer for the capture periods. We use the SSO on the playback
62 * channel to clock out virtual periods, and adjust the virtual period length
63 * to maintain synchronization. This algorithm came from the Trident driver.
64 *
65 * FIXME: It'd be nice to make use of some of the synth features in the
66 * hardware, but a woeful lack of documentation is a significant roadblock.
67 */
68 struct voice {
69 u16 flags;
70 #define VOICE_IN_USE 1
71 #define VOICE_CAPTURE 2
72 #define VOICE_SSO_TIMING 4
73 #define VOICE_SYNC_TIMING 8
74 u16 sync_cso;
75 u16 period_size;
76 u16 buffer_size;
77 u16 sync_period_size;
78 u16 sync_buffer_size;
79 u32 sso;
80 u32 vperiod;
81 struct snd_pcm_substream *substream;
82 struct voice *timing;
83 void __iomem *ctrl_base;
84 void __iomem *wave_base;
85 void __iomem *sync_base;
86 int num;
87 };
88
89 /* We need four pages to store our wave parameters during a suspend. If
90 * we're not doing power management, we still need to allocate a page
91 * for the silence buffer.
92 */
93 #define SIS_SUSPEND_PAGES 4
94
95 struct sis7019 {
96 unsigned long ioport;
97 void __iomem *ioaddr;
98 int irq;
99 int codecs_present;
100
101 struct pci_dev *pci;
102 struct snd_pcm *pcm;
103 struct snd_card *card;
104 struct snd_ac97 *ac97[3];
105
106 /* Protect against more than one thread hitting the AC97
107 * registers (in a more polite manner than pounding the hardware
108 * semaphore)
109 */
110 struct mutex ac97_mutex;
111
112 /* voice_lock protects allocation/freeing of the voice descriptions
113 */
114 spinlock_t voice_lock;
115
116 struct voice voices[64];
117 struct voice capture_voice;
118
119 /* Allocate pages to store the internal wave state during
120 * suspends. When we're operating, this can be used as a silence
121 * buffer for a timing channel.
122 */
123 void *suspend_state[SIS_SUSPEND_PAGES];
124
125 int silence_users;
126 dma_addr_t silence_dma_addr;
127 };
128
129 /* These values are also used by the module param 'codecs' to indicate
130 * which codecs should be present.
131 */
132 #define SIS_PRIMARY_CODEC_PRESENT 0x0001
133 #define SIS_SECONDARY_CODEC_PRESENT 0x0002
134 #define SIS_TERTIARY_CODEC_PRESENT 0x0004
135
136 /* The HW offset parameters (Loop End, Stop Sample, End Sample) have a
137 * documented range of 8-0xfff8 samples. Given that they are 0-based,
138 * that places our period/buffer range at 9-0xfff9 samples. That makes the
139 * max buffer size 0xfff9 samples * 2 channels * 2 bytes per sample, and
140 * max samples / min samples gives us the max periods in a buffer.
141 *
142 * We'll add a constraint upon open that limits the period and buffer sample
143 * size to values that are legal for the hardware.
144 */
145 static const struct snd_pcm_hardware sis_playback_hw_info = {
146 .info = (SNDRV_PCM_INFO_MMAP |
147 SNDRV_PCM_INFO_MMAP_VALID |
148 SNDRV_PCM_INFO_INTERLEAVED |
149 SNDRV_PCM_INFO_BLOCK_TRANSFER |
150 SNDRV_PCM_INFO_SYNC_START |
151 SNDRV_PCM_INFO_RESUME),
152 .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 |
153 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE),
154 .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS,
155 .rate_min = 4000,
156 .rate_max = 48000,
157 .channels_min = 1,
158 .channels_max = 2,
159 .buffer_bytes_max = (0xfff9 * 4),
160 .period_bytes_min = 9,
161 .period_bytes_max = (0xfff9 * 4),
162 .periods_min = 1,
163 .periods_max = (0xfff9 / 9),
164 };
165
166 static const struct snd_pcm_hardware sis_capture_hw_info = {
167 .info = (SNDRV_PCM_INFO_MMAP |
168 SNDRV_PCM_INFO_MMAP_VALID |
169 SNDRV_PCM_INFO_INTERLEAVED |
170 SNDRV_PCM_INFO_BLOCK_TRANSFER |
171 SNDRV_PCM_INFO_SYNC_START |
172 SNDRV_PCM_INFO_RESUME),
173 .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 |
174 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE),
175 .rates = SNDRV_PCM_RATE_48000,
176 .rate_min = 4000,
177 .rate_max = 48000,
178 .channels_min = 1,
179 .channels_max = 2,
180 .buffer_bytes_max = (0xfff9 * 4),
181 .period_bytes_min = 9,
182 .period_bytes_max = (0xfff9 * 4),
183 .periods_min = 1,
184 .periods_max = (0xfff9 / 9),
185 };
186
187 static void sis_update_sso(struct voice *voice, u16 period)
188 {
189 void __iomem *base = voice->ctrl_base;
190
191 voice->sso += period;
192 if (voice->sso >= voice->buffer_size)
193 voice->sso -= voice->buffer_size;
194
195 /* Enforce the documented hardware minimum offset */
196 if (voice->sso < 8)
197 voice->sso = 8;
198
199 /* The SSO is in the upper 16 bits of the register. */
200 writew(voice->sso & 0xffff, base + SIS_PLAY_DMA_SSO_ESO + 2);
201 }
202
203 static void sis_update_voice(struct voice *voice)
204 {
205 if (voice->flags & VOICE_SSO_TIMING) {
206 sis_update_sso(voice, voice->period_size);
207 } else if (voice->flags & VOICE_SYNC_TIMING) {
208 int sync;
209
210 /* If we've not hit the end of the virtual period, update
211 * our records and keep going.
212 */
213 if (voice->vperiod > voice->period_size) {
214 voice->vperiod -= voice->period_size;
215 if (voice->vperiod < voice->period_size)
216 sis_update_sso(voice, voice->vperiod);
217 else
218 sis_update_sso(voice, voice->period_size);
219 return;
220 }
221
222 /* Calculate our relative offset between the target and
223 * the actual CSO value. Since we're operating in a loop,
224 * if the value is more than half way around, we can
225 * consider ourselves wrapped.
226 */
227 sync = voice->sync_cso;
228 sync -= readw(voice->sync_base + SIS_CAPTURE_DMA_FORMAT_CSO);
229 if (sync > (voice->sync_buffer_size / 2))
230 sync -= voice->sync_buffer_size;
231
232 /* If sync is positive, then we interrupted too early, and
233 * we'll need to come back in a few samples and try again.
234 * There's a minimum wait, as it takes some time for the DMA
235 * engine to startup, etc...
236 */
237 if (sync > 0) {
238 if (sync < 16)
239 sync = 16;
240 sis_update_sso(voice, sync);
241 return;
242 }
243
244 /* Ok, we interrupted right on time, or (hopefully) just
245 * a bit late. We'll adjst our next waiting period based
246 * on how close we got.
247 *
248 * We need to stay just behind the actual channel to ensure
249 * it really is past a period when we get our interrupt --
250 * otherwise we'll fall into the early code above and have
251 * a minimum wait time, which makes us quite late here,
252 * eating into the user's time to refresh the buffer, esp.
253 * if using small periods.
254 *
255 * If we're less than 9 samples behind, we're on target.
256 * Otherwise, shorten the next vperiod by the amount we've
257 * been delayed.
258 */
259 if (sync > -9)
260 voice->vperiod = voice->sync_period_size + 1;
261 else
262 voice->vperiod = voice->sync_period_size + sync + 10;
263
264 if (voice->vperiod < voice->buffer_size) {
265 sis_update_sso(voice, voice->vperiod);
266 voice->vperiod = 0;
267 } else
268 sis_update_sso(voice, voice->period_size);
269
270 sync = voice->sync_cso + voice->sync_period_size;
271 if (sync >= voice->sync_buffer_size)
272 sync -= voice->sync_buffer_size;
273 voice->sync_cso = sync;
274 }
275
276 snd_pcm_period_elapsed(voice->substream);
277 }
278
279 static void sis_voice_irq(u32 status, struct voice *voice)
280 {
281 int bit;
282
283 while (status) {
284 bit = __ffs(status);
285 status >>= bit + 1;
286 voice += bit;
287 sis_update_voice(voice);
288 voice++;
289 }
290 }
291
292 static irqreturn_t sis_interrupt(int irq, void *dev)
293 {
294 struct sis7019 *sis = dev;
295 unsigned long io = sis->ioport;
296 struct voice *voice;
297 u32 intr, status;
298
299 /* We only use the DMA interrupts, and we don't enable any other
300 * source of interrupts. But, it is possible to see an interrupt
301 * status that didn't actually interrupt us, so eliminate anything
302 * we're not expecting to avoid falsely claiming an IRQ, and an
303 * ensuing endless loop.
304 */
305 intr = inl(io + SIS_GISR);
306 intr &= SIS_GISR_AUDIO_PLAY_DMA_IRQ_STATUS |
307 SIS_GISR_AUDIO_RECORD_DMA_IRQ_STATUS;
308 if (!intr)
309 return IRQ_NONE;
310
311 do {
312 status = inl(io + SIS_PISR_A);
313 if (status) {
314 sis_voice_irq(status, sis->voices);
315 outl(status, io + SIS_PISR_A);
316 }
317
318 status = inl(io + SIS_PISR_B);
319 if (status) {
320 sis_voice_irq(status, &sis->voices[32]);
321 outl(status, io + SIS_PISR_B);
322 }
323
324 status = inl(io + SIS_RISR);
325 if (status) {
326 voice = &sis->capture_voice;
327 if (!voice->timing)
328 snd_pcm_period_elapsed(voice->substream);
329
330 outl(status, io + SIS_RISR);
331 }
332
333 outl(intr, io + SIS_GISR);
334 intr = inl(io + SIS_GISR);
335 intr &= SIS_GISR_AUDIO_PLAY_DMA_IRQ_STATUS |
336 SIS_GISR_AUDIO_RECORD_DMA_IRQ_STATUS;
337 } while (intr);
338
339 return IRQ_HANDLED;
340 }
341
342 static u32 sis_rate_to_delta(unsigned int rate)
343 {
344 u32 delta;
345
346 /* This was copied from the trident driver, but it seems its gotten
347 * around a bit... nevertheless, it works well.
348 *
349 * We special case 44100 and 8000 since rounding with the equation
350 * does not give us an accurate enough value. For 11025 and 22050
351 * the equation gives us the best answer. All other frequencies will
352 * also use the equation. JDW
353 */
354 if (rate == 44100)
355 delta = 0xeb3;
356 else if (rate == 8000)
357 delta = 0x2ab;
358 else if (rate == 48000)
359 delta = 0x1000;
360 else
361 delta = DIV_ROUND_CLOSEST(rate << 12, 48000) & 0x0000ffff;
362 return delta;
363 }
364
365 static void __sis_map_silence(struct sis7019 *sis)
366 {
367 /* Helper function: must hold sis->voice_lock on entry */
368 if (!sis->silence_users)
369 sis->silence_dma_addr = dma_map_single(&sis->pci->dev,
370 sis->suspend_state[0],
371 4096, DMA_TO_DEVICE);
372 sis->silence_users++;
373 }
374
375 static void __sis_unmap_silence(struct sis7019 *sis)
376 {
377 /* Helper function: must hold sis->voice_lock on entry */
378 sis->silence_users--;
379 if (!sis->silence_users)
380 dma_unmap_single(&sis->pci->dev, sis->silence_dma_addr, 4096,
381 DMA_TO_DEVICE);
382 }
383
384 static void sis_free_voice(struct sis7019 *sis, struct voice *voice)
385 {
386 unsigned long flags;
387
388 spin_lock_irqsave(&sis->voice_lock, flags);
389 if (voice->timing) {
390 __sis_unmap_silence(sis);
391 voice->timing->flags &= ~(VOICE_IN_USE | VOICE_SSO_TIMING |
392 VOICE_SYNC_TIMING);
393 voice->timing = NULL;
394 }
395 voice->flags &= ~(VOICE_IN_USE | VOICE_SSO_TIMING | VOICE_SYNC_TIMING);
396 spin_unlock_irqrestore(&sis->voice_lock, flags);
397 }
398
399 static struct voice *__sis_alloc_playback_voice(struct sis7019 *sis)
400 {
401 /* Must hold the voice_lock on entry */
402 struct voice *voice;
403 int i;
404
405 for (i = 0; i < 64; i++) {
406 voice = &sis->voices[i];
407 if (voice->flags & VOICE_IN_USE)
408 continue;
409 voice->flags |= VOICE_IN_USE;
410 goto found_one;
411 }
412 voice = NULL;
413
414 found_one:
415 return voice;
416 }
417
418 static struct voice *sis_alloc_playback_voice(struct sis7019 *sis)
419 {
420 struct voice *voice;
421 unsigned long flags;
422
423 spin_lock_irqsave(&sis->voice_lock, flags);
424 voice = __sis_alloc_playback_voice(sis);
425 spin_unlock_irqrestore(&sis->voice_lock, flags);
426
427 return voice;
428 }
429
430 static int sis_alloc_timing_voice(struct snd_pcm_substream *substream,
431 struct snd_pcm_hw_params *hw_params)
432 {
433 struct sis7019 *sis = snd_pcm_substream_chip(substream);
434 struct snd_pcm_runtime *runtime = substream->runtime;
435 struct voice *voice = runtime->private_data;
436 unsigned int period_size, buffer_size;
437 unsigned long flags;
438 int needed;
439
440 /* If there are one or two periods per buffer, we don't need a
441 * timing voice, as we can use the capture channel's interrupts
442 * to clock out the periods.
443 */
444 period_size = params_period_size(hw_params);
445 buffer_size = params_buffer_size(hw_params);
446 needed = (period_size != buffer_size &&
447 period_size != (buffer_size / 2));
448
449 if (needed && !voice->timing) {
450 spin_lock_irqsave(&sis->voice_lock, flags);
451 voice->timing = __sis_alloc_playback_voice(sis);
452 if (voice->timing)
453 __sis_map_silence(sis);
454 spin_unlock_irqrestore(&sis->voice_lock, flags);
455 if (!voice->timing)
456 return -ENOMEM;
457 voice->timing->substream = substream;
458 } else if (!needed && voice->timing) {
459 sis_free_voice(sis, voice);
460 voice->timing = NULL;
461 }
462
463 return 0;
464 }
465
466 static int sis_playback_open(struct snd_pcm_substream *substream)
467 {
468 struct sis7019 *sis = snd_pcm_substream_chip(substream);
469 struct snd_pcm_runtime *runtime = substream->runtime;
470 struct voice *voice;
471
472 voice = sis_alloc_playback_voice(sis);
473 if (!voice)
474 return -EAGAIN;
475
476 voice->substream = substream;
477 runtime->private_data = voice;
478 runtime->hw = sis_playback_hw_info;
479 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
480 9, 0xfff9);
481 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
482 9, 0xfff9);
483 snd_pcm_set_sync(substream);
484 return 0;
485 }
486
487 static int sis_substream_close(struct snd_pcm_substream *substream)
488 {
489 struct sis7019 *sis = snd_pcm_substream_chip(substream);
490 struct snd_pcm_runtime *runtime = substream->runtime;
491 struct voice *voice = runtime->private_data;
492
493 sis_free_voice(sis, voice);
494 return 0;
495 }
496
497 static int sis_pcm_playback_prepare(struct snd_pcm_substream *substream)
498 {
499 struct snd_pcm_runtime *runtime = substream->runtime;
500 struct voice *voice = runtime->private_data;
501 void __iomem *ctrl_base = voice->ctrl_base;
502 void __iomem *wave_base = voice->wave_base;
503 u32 format, dma_addr, control, sso_eso, delta, reg;
504 u16 leo;
505
506 /* We rely on the PCM core to ensure that the parameters for this
507 * substream do not change on us while we're programming the HW.
508 */
509 format = 0;
510 if (snd_pcm_format_width(runtime->format) == 8)
511 format |= SIS_PLAY_DMA_FORMAT_8BIT;
512 if (!snd_pcm_format_signed(runtime->format))
513 format |= SIS_PLAY_DMA_FORMAT_UNSIGNED;
514 if (runtime->channels == 1)
515 format |= SIS_PLAY_DMA_FORMAT_MONO;
516
517 /* The baseline setup is for a single period per buffer, and
518 * we add bells and whistles as needed from there.
519 */
520 dma_addr = runtime->dma_addr;
521 leo = runtime->buffer_size - 1;
522 control = leo | SIS_PLAY_DMA_LOOP | SIS_PLAY_DMA_INTR_AT_LEO;
523 sso_eso = leo;
524
525 if (runtime->period_size == (runtime->buffer_size / 2)) {
526 control |= SIS_PLAY_DMA_INTR_AT_MLP;
527 } else if (runtime->period_size != runtime->buffer_size) {
528 voice->flags |= VOICE_SSO_TIMING;
529 voice->sso = runtime->period_size - 1;
530 voice->period_size = runtime->period_size;
531 voice->buffer_size = runtime->buffer_size;
532
533 control &= ~SIS_PLAY_DMA_INTR_AT_LEO;
534 control |= SIS_PLAY_DMA_INTR_AT_SSO;
535 sso_eso |= (runtime->period_size - 1) << 16;
536 }
537
538 delta = sis_rate_to_delta(runtime->rate);
539
540 /* Ok, we're ready to go, set up the channel.
541 */
542 writel(format, ctrl_base + SIS_PLAY_DMA_FORMAT_CSO);
543 writel(dma_addr, ctrl_base + SIS_PLAY_DMA_BASE);
544 writel(control, ctrl_base + SIS_PLAY_DMA_CONTROL);
545 writel(sso_eso, ctrl_base + SIS_PLAY_DMA_SSO_ESO);
546
547 for (reg = 0; reg < SIS_WAVE_SIZE; reg += 4)
548 writel(0, wave_base + reg);
549
550 writel(SIS_WAVE_GENERAL_WAVE_VOLUME, wave_base + SIS_WAVE_GENERAL);
551 writel(delta << 16, wave_base + SIS_WAVE_GENERAL_ARTICULATION);
552 writel(SIS_WAVE_CHANNEL_CONTROL_FIRST_SAMPLE |
553 SIS_WAVE_CHANNEL_CONTROL_AMP_ENABLE |
554 SIS_WAVE_CHANNEL_CONTROL_INTERPOLATE_ENABLE,
555 wave_base + SIS_WAVE_CHANNEL_CONTROL);
556
557 /* Force PCI writes to post. */
558 readl(ctrl_base);
559
560 return 0;
561 }
562
563 static int sis_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
564 {
565 struct sis7019 *sis = snd_pcm_substream_chip(substream);
566 unsigned long io = sis->ioport;
567 struct snd_pcm_substream *s;
568 struct voice *voice;
569 void *chip;
570 int starting;
571 u32 record = 0;
572 u32 play[2] = { 0, 0 };
573
574 /* No locks needed, as the PCM core will hold the locks on the
575 * substreams, and the HW will only start/stop the indicated voices
576 * without changing the state of the others.
577 */
578 switch (cmd) {
579 case SNDRV_PCM_TRIGGER_START:
580 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
581 case SNDRV_PCM_TRIGGER_RESUME:
582 starting = 1;
583 break;
584 case SNDRV_PCM_TRIGGER_STOP:
585 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
586 case SNDRV_PCM_TRIGGER_SUSPEND:
587 starting = 0;
588 break;
589 default:
590 return -EINVAL;
591 }
592
593 snd_pcm_group_for_each_entry(s, substream) {
594 /* Make sure it is for us... */
595 chip = snd_pcm_substream_chip(s);
596 if (chip != sis)
597 continue;
598
599 voice = s->runtime->private_data;
600 if (voice->flags & VOICE_CAPTURE) {
601 record |= 1 << voice->num;
602 voice = voice->timing;
603 }
604
605 /* voice could be NULL if this a recording stream, and it
606 * doesn't have an external timing channel.
607 */
608 if (voice)
609 play[voice->num / 32] |= 1 << (voice->num & 0x1f);
610
611 snd_pcm_trigger_done(s, substream);
612 }
613
614 if (starting) {
615 if (record)
616 outl(record, io + SIS_RECORD_START_REG);
617 if (play[0])
618 outl(play[0], io + SIS_PLAY_START_A_REG);
619 if (play[1])
620 outl(play[1], io + SIS_PLAY_START_B_REG);
621 } else {
622 if (record)
623 outl(record, io + SIS_RECORD_STOP_REG);
624 if (play[0])
625 outl(play[0], io + SIS_PLAY_STOP_A_REG);
626 if (play[1])
627 outl(play[1], io + SIS_PLAY_STOP_B_REG);
628 }
629 return 0;
630 }
631
632 static snd_pcm_uframes_t sis_pcm_pointer(struct snd_pcm_substream *substream)
633 {
634 struct snd_pcm_runtime *runtime = substream->runtime;
635 struct voice *voice = runtime->private_data;
636 u32 cso;
637
638 cso = readl(voice->ctrl_base + SIS_PLAY_DMA_FORMAT_CSO);
639 cso &= 0xffff;
640 return cso;
641 }
642
643 static int sis_capture_open(struct snd_pcm_substream *substream)
644 {
645 struct sis7019 *sis = snd_pcm_substream_chip(substream);
646 struct snd_pcm_runtime *runtime = substream->runtime;
647 struct voice *voice = &sis->capture_voice;
648 unsigned long flags;
649
650 /* FIXME: The driver only supports recording from one channel
651 * at the moment, but it could support more.
652 */
653 spin_lock_irqsave(&sis->voice_lock, flags);
654 if (voice->flags & VOICE_IN_USE)
655 voice = NULL;
656 else
657 voice->flags |= VOICE_IN_USE;
658 spin_unlock_irqrestore(&sis->voice_lock, flags);
659
660 if (!voice)
661 return -EAGAIN;
662
663 voice->substream = substream;
664 runtime->private_data = voice;
665 runtime->hw = sis_capture_hw_info;
666 runtime->hw.rates = sis->ac97[0]->rates[AC97_RATES_ADC];
667 snd_pcm_limit_hw_rates(runtime);
668 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
669 9, 0xfff9);
670 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
671 9, 0xfff9);
672 snd_pcm_set_sync(substream);
673 return 0;
674 }
675
676 static int sis_capture_hw_params(struct snd_pcm_substream *substream,
677 struct snd_pcm_hw_params *hw_params)
678 {
679 struct sis7019 *sis = snd_pcm_substream_chip(substream);
680 int rc;
681
682 rc = snd_ac97_set_rate(sis->ac97[0], AC97_PCM_LR_ADC_RATE,
683 params_rate(hw_params));
684 if (rc)
685 goto out;
686
687 rc = sis_alloc_timing_voice(substream, hw_params);
688
689 out:
690 return rc;
691 }
692
693 static void sis_prepare_timing_voice(struct voice *voice,
694 struct snd_pcm_substream *substream)
695 {
696 struct sis7019 *sis = snd_pcm_substream_chip(substream);
697 struct snd_pcm_runtime *runtime = substream->runtime;
698 struct voice *timing = voice->timing;
699 void __iomem *play_base = timing->ctrl_base;
700 void __iomem *wave_base = timing->wave_base;
701 u16 buffer_size, period_size;
702 u32 format, control, sso_eso, delta;
703 u32 vperiod, sso, reg;
704
705 /* Set our initial buffer and period as large as we can given a
706 * single page of silence.
707 */
708 buffer_size = 4096 / runtime->channels;
709 buffer_size /= snd_pcm_format_size(runtime->format, 1);
710 period_size = buffer_size;
711
712 /* Initially, we want to interrupt just a bit behind the end of
713 * the period we're clocking out. 12 samples seems to give a good
714 * delay.
715 *
716 * We want to spread our interrupts throughout the virtual period,
717 * so that we don't end up with two interrupts back to back at the
718 * end -- this helps minimize the effects of any jitter. Adjust our
719 * clocking period size so that the last period is at least a fourth
720 * of a full period.
721 *
722 * This is all moot if we don't need to use virtual periods.
723 */
724 vperiod = runtime->period_size + 12;
725 if (vperiod > period_size) {
726 u16 tail = vperiod % period_size;
727 u16 quarter_period = period_size / 4;
728
729 if (tail && tail < quarter_period) {
730 u16 loops = vperiod / period_size;
731
732 tail = quarter_period - tail;
733 tail += loops - 1;
734 tail /= loops;
735 period_size -= tail;
736 }
737
738 sso = period_size - 1;
739 } else {
740 /* The initial period will fit inside the buffer, so we
741 * don't need to use virtual periods -- disable them.
742 */
743 period_size = runtime->period_size;
744 sso = vperiod - 1;
745 vperiod = 0;
746 }
747
748 /* The interrupt handler implements the timing synchronization, so
749 * setup its state.
750 */
751 timing->flags |= VOICE_SYNC_TIMING;
752 timing->sync_base = voice->ctrl_base;
753 timing->sync_cso = runtime->period_size;
754 timing->sync_period_size = runtime->period_size;
755 timing->sync_buffer_size = runtime->buffer_size;
756 timing->period_size = period_size;
757 timing->buffer_size = buffer_size;
758 timing->sso = sso;
759 timing->vperiod = vperiod;
760
761 /* Using unsigned samples with the all-zero silence buffer
762 * forces the output to the lower rail, killing playback.
763 * So ignore unsigned vs signed -- it doesn't change the timing.
764 */
765 format = 0;
766 if (snd_pcm_format_width(runtime->format) == 8)
767 format = SIS_CAPTURE_DMA_FORMAT_8BIT;
768 if (runtime->channels == 1)
769 format |= SIS_CAPTURE_DMA_FORMAT_MONO;
770
771 control = timing->buffer_size - 1;
772 control |= SIS_PLAY_DMA_LOOP | SIS_PLAY_DMA_INTR_AT_SSO;
773 sso_eso = timing->buffer_size - 1;
774 sso_eso |= timing->sso << 16;
775
776 delta = sis_rate_to_delta(runtime->rate);
777
778 /* We've done the math, now configure the channel.
779 */
780 writel(format, play_base + SIS_PLAY_DMA_FORMAT_CSO);
781 writel(sis->silence_dma_addr, play_base + SIS_PLAY_DMA_BASE);
782 writel(control, play_base + SIS_PLAY_DMA_CONTROL);
783 writel(sso_eso, play_base + SIS_PLAY_DMA_SSO_ESO);
784
785 for (reg = 0; reg < SIS_WAVE_SIZE; reg += 4)
786 writel(0, wave_base + reg);
787
788 writel(SIS_WAVE_GENERAL_WAVE_VOLUME, wave_base + SIS_WAVE_GENERAL);
789 writel(delta << 16, wave_base + SIS_WAVE_GENERAL_ARTICULATION);
790 writel(SIS_WAVE_CHANNEL_CONTROL_FIRST_SAMPLE |
791 SIS_WAVE_CHANNEL_CONTROL_AMP_ENABLE |
792 SIS_WAVE_CHANNEL_CONTROL_INTERPOLATE_ENABLE,
793 wave_base + SIS_WAVE_CHANNEL_CONTROL);
794 }
795
796 static int sis_pcm_capture_prepare(struct snd_pcm_substream *substream)
797 {
798 struct snd_pcm_runtime *runtime = substream->runtime;
799 struct voice *voice = runtime->private_data;
800 void __iomem *rec_base = voice->ctrl_base;
801 u32 format, dma_addr, control;
802 u16 leo;
803
804 /* We rely on the PCM core to ensure that the parameters for this
805 * substream do not change on us while we're programming the HW.
806 */
807 format = 0;
808 if (snd_pcm_format_width(runtime->format) == 8)
809 format = SIS_CAPTURE_DMA_FORMAT_8BIT;
810 if (!snd_pcm_format_signed(runtime->format))
811 format |= SIS_CAPTURE_DMA_FORMAT_UNSIGNED;
812 if (runtime->channels == 1)
813 format |= SIS_CAPTURE_DMA_FORMAT_MONO;
814
815 dma_addr = runtime->dma_addr;
816 leo = runtime->buffer_size - 1;
817 control = leo | SIS_CAPTURE_DMA_LOOP;
818
819 /* If we've got more than two periods per buffer, then we have
820 * use a timing voice to clock out the periods. Otherwise, we can
821 * use the capture channel's interrupts.
822 */
823 if (voice->timing) {
824 sis_prepare_timing_voice(voice, substream);
825 } else {
826 control |= SIS_CAPTURE_DMA_INTR_AT_LEO;
827 if (runtime->period_size != runtime->buffer_size)
828 control |= SIS_CAPTURE_DMA_INTR_AT_MLP;
829 }
830
831 writel(format, rec_base + SIS_CAPTURE_DMA_FORMAT_CSO);
832 writel(dma_addr, rec_base + SIS_CAPTURE_DMA_BASE);
833 writel(control, rec_base + SIS_CAPTURE_DMA_CONTROL);
834
835 /* Force the writes to post. */
836 readl(rec_base);
837
838 return 0;
839 }
840
841 static const struct snd_pcm_ops sis_playback_ops = {
842 .open = sis_playback_open,
843 .close = sis_substream_close,
844 .prepare = sis_pcm_playback_prepare,
845 .trigger = sis_pcm_trigger,
846 .pointer = sis_pcm_pointer,
847 };
848
849 static const struct snd_pcm_ops sis_capture_ops = {
850 .open = sis_capture_open,
851 .close = sis_substream_close,
852 .hw_params = sis_capture_hw_params,
853 .prepare = sis_pcm_capture_prepare,
854 .trigger = sis_pcm_trigger,
855 .pointer = sis_pcm_pointer,
856 };
857
858 static int sis_pcm_create(struct sis7019 *sis)
859 {
860 struct snd_pcm *pcm;
861 int rc;
862
863 /* We have 64 voices, and the driver currently records from
864 * only one channel, though that could change in the future.
865 */
866 rc = snd_pcm_new(sis->card, "SiS7019", 0, 64, 1, &pcm);
867 if (rc)
868 return rc;
869
870 pcm->private_data = sis;
871 strcpy(pcm->name, "SiS7019");
872 sis->pcm = pcm;
873
874 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &sis_playback_ops);
875 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &sis_capture_ops);
876
877 /* Try to preallocate some memory, but it's not the end of the
878 * world if this fails.
879 */
880 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
881 &sis->pci->dev, 64*1024, 128*1024);
882
883 return 0;
884 }
885
886 static unsigned short sis_ac97_rw(struct sis7019 *sis, int codec, u32 cmd)
887 {
888 unsigned long io = sis->ioport;
889 unsigned short val = 0xffff;
890 u16 status;
891 u16 rdy;
892 int count;
893 static const u16 codec_ready[3] = {
894 SIS_AC97_STATUS_CODEC_READY,
895 SIS_AC97_STATUS_CODEC2_READY,
896 SIS_AC97_STATUS_CODEC3_READY,
897 };
898
899 rdy = codec_ready[codec];
900
901
902 /* Get the AC97 semaphore -- software first, so we don't spin
903 * pounding out IO reads on the hardware semaphore...
904 */
905 mutex_lock(&sis->ac97_mutex);
906
907 count = 0xffff;
908 while ((inw(io + SIS_AC97_SEMA) & SIS_AC97_SEMA_BUSY) && --count)
909 udelay(1);
910
911 if (!count)
912 goto timeout;
913
914 /* ... and wait for any outstanding commands to complete ...
915 */
916 count = 0xffff;
917 do {
918 status = inw(io + SIS_AC97_STATUS);
919 if ((status & rdy) && !(status & SIS_AC97_STATUS_BUSY))
920 break;
921
922 udelay(1);
923 } while (--count);
924
925 if (!count)
926 goto timeout_sema;
927
928 /* ... before sending our command and waiting for it to finish ...
929 */
930 outl(cmd, io + SIS_AC97_CMD);
931 udelay(10);
932
933 count = 0xffff;
934 while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count)
935 udelay(1);
936
937 /* ... and reading the results (if any).
938 */
939 val = inl(io + SIS_AC97_CMD) >> 16;
940
941 timeout_sema:
942 outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA);
943 timeout:
944 mutex_unlock(&sis->ac97_mutex);
945
946 if (!count) {
947 dev_err(&sis->pci->dev, "ac97 codec %d timeout cmd 0x%08x\n",
948 codec, cmd);
949 }
950
951 return val;
952 }
953
954 static void sis_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
955 unsigned short val)
956 {
957 static const u32 cmd[3] = {
958 SIS_AC97_CMD_CODEC_WRITE,
959 SIS_AC97_CMD_CODEC2_WRITE,
960 SIS_AC97_CMD_CODEC3_WRITE,
961 };
962 sis_ac97_rw(ac97->private_data, ac97->num,
963 (val << 16) | (reg << 8) | cmd[ac97->num]);
964 }
965
966 static unsigned short sis_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
967 {
968 static const u32 cmd[3] = {
969 SIS_AC97_CMD_CODEC_READ,
970 SIS_AC97_CMD_CODEC2_READ,
971 SIS_AC97_CMD_CODEC3_READ,
972 };
973 return sis_ac97_rw(ac97->private_data, ac97->num,
974 (reg << 8) | cmd[ac97->num]);
975 }
976
977 static int sis_mixer_create(struct sis7019 *sis)
978 {
979 struct snd_ac97_bus *bus;
980 struct snd_ac97_template ac97;
981 static const struct snd_ac97_bus_ops ops = {
982 .write = sis_ac97_write,
983 .read = sis_ac97_read,
984 };
985 int rc;
986
987 memset(&ac97, 0, sizeof(ac97));
988 ac97.private_data = sis;
989
990 rc = snd_ac97_bus(sis->card, 0, &ops, NULL, &bus);
991 if (!rc && sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT)
992 rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[0]);
993 ac97.num = 1;
994 if (!rc && (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT))
995 rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[1]);
996 ac97.num = 2;
997 if (!rc && (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT))
998 rc = snd_ac97_mixer(bus, &ac97, &sis->ac97[2]);
999
1000 /* If we return an error here, then snd_card_free() should
1001 * free up any ac97 codecs that got created, as well as the bus.
1002 */
1003 return rc;
1004 }
1005
1006 static void sis_chip_free(struct snd_card *card)
1007 {
1008 struct sis7019 *sis = card->private_data;
1009
1010 /* Reset the chip, and disable all interrputs.
1011 */
1012 outl(SIS_GCR_SOFTWARE_RESET, sis->ioport + SIS_GCR);
1013 udelay(25);
1014 outl(0, sis->ioport + SIS_GCR);
1015 outl(0, sis->ioport + SIS_GIER);
1016
1017 /* Now, free everything we allocated.
1018 */
1019 if (sis->irq >= 0)
1020 free_irq(sis->irq, sis);
1021 }
1022
1023 static int sis_chip_init(struct sis7019 *sis)
1024 {
1025 unsigned long io = sis->ioport;
1026 void __iomem *ioaddr = sis->ioaddr;
1027 unsigned long timeout;
1028 u16 status;
1029 int count;
1030 int i;
1031
1032 /* Reset the audio controller
1033 */
1034 outl(SIS_GCR_SOFTWARE_RESET, io + SIS_GCR);
1035 udelay(25);
1036 outl(0, io + SIS_GCR);
1037
1038 /* Get the AC-link semaphore, and reset the codecs
1039 */
1040 count = 0xffff;
1041 while ((inw(io + SIS_AC97_SEMA) & SIS_AC97_SEMA_BUSY) && --count)
1042 udelay(1);
1043
1044 if (!count)
1045 return -EIO;
1046
1047 outl(SIS_AC97_CMD_CODEC_COLD_RESET, io + SIS_AC97_CMD);
1048 udelay(250);
1049
1050 count = 0xffff;
1051 while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count)
1052 udelay(1);
1053
1054 /* Command complete, we can let go of the semaphore now.
1055 */
1056 outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA);
1057 if (!count)
1058 return -EIO;
1059
1060 /* Now that we've finished the reset, find out what's attached.
1061 * There are some codec/board combinations that take an extremely
1062 * long time to come up. 350+ ms has been observed in the field,
1063 * so we'll give them up to 500ms.
1064 */
1065 sis->codecs_present = 0;
1066 timeout = msecs_to_jiffies(500) + jiffies;
1067 while (time_before_eq(jiffies, timeout)) {
1068 status = inl(io + SIS_AC97_STATUS);
1069 if (status & SIS_AC97_STATUS_CODEC_READY)
1070 sis->codecs_present |= SIS_PRIMARY_CODEC_PRESENT;
1071 if (status & SIS_AC97_STATUS_CODEC2_READY)
1072 sis->codecs_present |= SIS_SECONDARY_CODEC_PRESENT;
1073 if (status & SIS_AC97_STATUS_CODEC3_READY)
1074 sis->codecs_present |= SIS_TERTIARY_CODEC_PRESENT;
1075
1076 if (sis->codecs_present == codecs)
1077 break;
1078
1079 msleep(1);
1080 }
1081
1082 /* All done, check for errors.
1083 */
1084 if (!sis->codecs_present) {
1085 dev_err(&sis->pci->dev, "could not find any codecs\n");
1086 return -EIO;
1087 }
1088
1089 if (sis->codecs_present != codecs) {
1090 dev_warn(&sis->pci->dev, "missing codecs, found %0x, expected %0x\n",
1091 sis->codecs_present, codecs);
1092 }
1093
1094 /* Let the hardware know that the audio driver is alive,
1095 * and enable PCM slots on the AC-link for L/R playback (3 & 4) and
1096 * record channels. We're going to want to use Variable Rate Audio
1097 * for recording, to avoid needlessly resampling from 48kHZ.
1098 */
1099 outl(SIS_AC97_CONF_AUDIO_ALIVE, io + SIS_AC97_CONF);
1100 outl(SIS_AC97_CONF_AUDIO_ALIVE | SIS_AC97_CONF_PCM_LR_ENABLE |
1101 SIS_AC97_CONF_PCM_CAP_MIC_ENABLE |
1102 SIS_AC97_CONF_PCM_CAP_LR_ENABLE |
1103 SIS_AC97_CONF_CODEC_VRA_ENABLE, io + SIS_AC97_CONF);
1104
1105 /* All AC97 PCM slots should be sourced from sub-mixer 0.
1106 */
1107 outl(0, io + SIS_AC97_PSR);
1108
1109 /* There is only one valid DMA setup for a PCI environment.
1110 */
1111 outl(SIS_DMA_CSR_PCI_SETTINGS, io + SIS_DMA_CSR);
1112
1113 /* Reset the synchronization groups for all of the channels
1114 * to be asynchronous. If we start doing SPDIF or 5.1 sound, etc.
1115 * we'll need to change how we handle these. Until then, we just
1116 * assign sub-mixer 0 to all playback channels, and avoid any
1117 * attenuation on the audio.
1118 */
1119 outl(0, io + SIS_PLAY_SYNC_GROUP_A);
1120 outl(0, io + SIS_PLAY_SYNC_GROUP_B);
1121 outl(0, io + SIS_PLAY_SYNC_GROUP_C);
1122 outl(0, io + SIS_PLAY_SYNC_GROUP_D);
1123 outl(0, io + SIS_MIXER_SYNC_GROUP);
1124
1125 for (i = 0; i < 64; i++) {
1126 writel(i, SIS_MIXER_START_ADDR(ioaddr, i));
1127 writel(SIS_MIXER_RIGHT_NO_ATTEN | SIS_MIXER_LEFT_NO_ATTEN |
1128 SIS_MIXER_DEST_0, SIS_MIXER_ADDR(ioaddr, i));
1129 }
1130
1131 /* Don't attenuate any audio set for the wave amplifier.
1132 *
1133 * FIXME: Maximum attenuation is set for the music amp, which will
1134 * need to change if we start using the synth engine.
1135 */
1136 outl(0xffff0000, io + SIS_WEVCR);
1137
1138 /* Ensure that the wave engine is in normal operating mode.
1139 */
1140 outl(0, io + SIS_WECCR);
1141
1142 /* Go ahead and enable the DMA interrupts. They won't go live
1143 * until we start a channel.
1144 */
1145 outl(SIS_GIER_AUDIO_PLAY_DMA_IRQ_ENABLE |
1146 SIS_GIER_AUDIO_RECORD_DMA_IRQ_ENABLE, io + SIS_GIER);
1147
1148 return 0;
1149 }
1150
1151 static int sis_suspend(struct device *dev)
1152 {
1153 struct snd_card *card = dev_get_drvdata(dev);
1154 struct sis7019 *sis = card->private_data;
1155 void __iomem *ioaddr = sis->ioaddr;
1156 int i;
1157
1158 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1159 if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT)
1160 snd_ac97_suspend(sis->ac97[0]);
1161 if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT)
1162 snd_ac97_suspend(sis->ac97[1]);
1163 if (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT)
1164 snd_ac97_suspend(sis->ac97[2]);
1165
1166 /* snd_pcm_suspend_all() stopped all channels, so we're quiescent.
1167 */
1168 if (sis->irq >= 0) {
1169 free_irq(sis->irq, sis);
1170 sis->irq = -1;
1171 }
1172
1173 /* Save the internal state away
1174 */
1175 for (i = 0; i < 4; i++) {
1176 memcpy_fromio(sis->suspend_state[i], ioaddr, 4096);
1177 ioaddr += 4096;
1178 }
1179
1180 return 0;
1181 }
1182
1183 static int sis_resume(struct device *dev)
1184 {
1185 struct pci_dev *pci = to_pci_dev(dev);
1186 struct snd_card *card = dev_get_drvdata(dev);
1187 struct sis7019 *sis = card->private_data;
1188 void __iomem *ioaddr = sis->ioaddr;
1189 int i;
1190
1191 if (sis_chip_init(sis)) {
1192 dev_err(&pci->dev, "unable to re-init controller\n");
1193 goto error;
1194 }
1195
1196 if (request_irq(pci->irq, sis_interrupt, IRQF_SHARED,
1197 KBUILD_MODNAME, sis)) {
1198 dev_err(&pci->dev, "unable to regain IRQ %d\n", pci->irq);
1199 goto error;
1200 }
1201
1202 /* Restore saved state, then clear out the page we use for the
1203 * silence buffer.
1204 */
1205 for (i = 0; i < 4; i++) {
1206 memcpy_toio(ioaddr, sis->suspend_state[i], 4096);
1207 ioaddr += 4096;
1208 }
1209
1210 memset(sis->suspend_state[0], 0, 4096);
1211
1212 sis->irq = pci->irq;
1213
1214 if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT)
1215 snd_ac97_resume(sis->ac97[0]);
1216 if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT)
1217 snd_ac97_resume(sis->ac97[1]);
1218 if (sis->codecs_present & SIS_TERTIARY_CODEC_PRESENT)
1219 snd_ac97_resume(sis->ac97[2]);
1220
1221 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1222 return 0;
1223
1224 error:
1225 snd_card_disconnect(card);
1226 return -EIO;
1227 }
1228
1229 static DEFINE_SIMPLE_DEV_PM_OPS(sis_pm, sis_suspend, sis_resume);
1230
1231 static int sis_alloc_suspend(struct sis7019 *sis)
1232 {
1233 int i;
1234
1235 /* We need 16K to store the internal wave engine state during a
1236 * suspend, but we don't need it to be contiguous, so play nice
1237 * with the memory system. We'll also use this area for a silence
1238 * buffer.
1239 */
1240 for (i = 0; i < SIS_SUSPEND_PAGES; i++) {
1241 sis->suspend_state[i] = devm_kmalloc(&sis->pci->dev, 4096,
1242 GFP_KERNEL);
1243 if (!sis->suspend_state[i])
1244 return -ENOMEM;
1245 }
1246 memset(sis->suspend_state[0], 0, 4096);
1247
1248 return 0;
1249 }
1250
1251 static int sis_chip_create(struct snd_card *card,
1252 struct pci_dev *pci)
1253 {
1254 struct sis7019 *sis = card->private_data;
1255 struct voice *voice;
1256 int rc;
1257 int i;
1258
1259 rc = pcim_enable_device(pci);
1260 if (rc)
1261 return rc;
1262
1263 rc = dma_set_mask(&pci->dev, DMA_BIT_MASK(30));
1264 if (rc < 0) {
1265 dev_err(&pci->dev, "architecture does not support 30-bit PCI busmaster DMA");
1266 return -ENXIO;
1267 }
1268
1269 mutex_init(&sis->ac97_mutex);
1270 spin_lock_init(&sis->voice_lock);
1271 sis->card = card;
1272 sis->pci = pci;
1273 sis->irq = -1;
1274 sis->ioport = pci_resource_start(pci, 0);
1275
1276 rc = pci_request_regions(pci, "SiS7019");
1277 if (rc) {
1278 dev_err(&pci->dev, "unable request regions\n");
1279 return rc;
1280 }
1281
1282 sis->ioaddr = devm_ioremap(&pci->dev, pci_resource_start(pci, 1), 0x4000);
1283 if (!sis->ioaddr) {
1284 dev_err(&pci->dev, "unable to remap MMIO, aborting\n");
1285 return -EIO;
1286 }
1287
1288 rc = sis_alloc_suspend(sis);
1289 if (rc < 0) {
1290 dev_err(&pci->dev, "unable to allocate state storage\n");
1291 return rc;
1292 }
1293
1294 rc = sis_chip_init(sis);
1295 if (rc)
1296 return rc;
1297 card->private_free = sis_chip_free;
1298
1299 rc = request_irq(pci->irq, sis_interrupt, IRQF_SHARED, KBUILD_MODNAME,
1300 sis);
1301 if (rc) {
1302 dev_err(&pci->dev, "unable to allocate irq %d\n", sis->irq);
1303 return rc;
1304 }
1305
1306 sis->irq = pci->irq;
1307 card->sync_irq = sis->irq;
1308 pci_set_master(pci);
1309
1310 for (i = 0; i < 64; i++) {
1311 voice = &sis->voices[i];
1312 voice->num = i;
1313 voice->ctrl_base = SIS_PLAY_DMA_ADDR(sis->ioaddr, i);
1314 voice->wave_base = SIS_WAVE_ADDR(sis->ioaddr, i);
1315 }
1316
1317 voice = &sis->capture_voice;
1318 voice->flags = VOICE_CAPTURE;
1319 voice->num = SIS_CAPTURE_CHAN_AC97_PCM_IN;
1320 voice->ctrl_base = SIS_CAPTURE_DMA_ADDR(sis->ioaddr, voice->num);
1321
1322 return 0;
1323 }
1324
1325 static int __snd_sis7019_probe(struct pci_dev *pci,
1326 const struct pci_device_id *pci_id)
1327 {
1328 struct snd_card *card;
1329 struct sis7019 *sis;
1330 int rc;
1331
1332 if (!enable)
1333 return -ENOENT;
1334
1335 /* The user can specify which codecs should be present so that we
1336 * can wait for them to show up if they are slow to recover from
1337 * the AC97 cold reset. We default to a single codec, the primary.
1338 *
1339 * We assume that SIS_PRIMARY_*_PRESENT matches bits 0-2.
1340 */
1341 codecs &= SIS_PRIMARY_CODEC_PRESENT | SIS_SECONDARY_CODEC_PRESENT |
1342 SIS_TERTIARY_CODEC_PRESENT;
1343 if (!codecs)
1344 codecs = SIS_PRIMARY_CODEC_PRESENT;
1345
1346 rc = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
1347 sizeof(*sis), &card);
1348 if (rc < 0)
1349 return rc;
1350
1351 strcpy(card->driver, "SiS7019");
1352 strcpy(card->shortname, "SiS7019");
1353 rc = sis_chip_create(card, pci);
1354 if (rc)
1355 return rc;
1356
1357 sis = card->private_data;
1358
1359 rc = sis_mixer_create(sis);
1360 if (rc)
1361 return rc;
1362
1363 rc = sis_pcm_create(sis);
1364 if (rc)
1365 return rc;
1366
1367 snprintf(card->longname, sizeof(card->longname),
1368 "%s Audio Accelerator with %s at 0x%lx, irq %d",
1369 card->shortname, snd_ac97_get_short_name(sis->ac97[0]),
1370 sis->ioport, sis->irq);
1371
1372 rc = snd_card_register(card);
1373 if (rc)
1374 return rc;
1375
1376 pci_set_drvdata(pci, card);
1377 return 0;
1378 }
1379
1380 static int snd_sis7019_probe(struct pci_dev *pci,
1381 const struct pci_device_id *pci_id)
1382 {
1383 return snd_card_free_on_error(&pci->dev, __snd_sis7019_probe(pci, pci_id));
1384 }
1385
1386 static struct pci_driver sis7019_driver = {
1387 .name = KBUILD_MODNAME,
1388 .id_table = snd_sis7019_ids,
1389 .probe = snd_sis7019_probe,
1390 .driver = {
1391 .pm = &sis_pm,
1392 },
1393 };
1394
1395 module_pci_driver(sis7019_driver);
1396
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.