auixp.c revision 1.41.2.2 1 /* $NetBSD: auixp.c,v 1.41.2.2 2017/08/28 17:52:05 skrll Exp $ */
2
3 /*
4 * Copyright (c) 2004, 2005 Reinoud Zandijk <reinoud (at) netbsd.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by the NetBSD
17 * Foundation, Inc. and its contributors.
18 * 4. Neither the name of The NetBSD Foundation nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35
36 /*
37 * NetBSD audio driver for ATI IXP-{150,200,...} audio driver hardware.
38 *
39 * Recording and playback has been tested OK on various sample rates and
40 * encodings.
41 *
42 * Known problems and issues :
43 * - SPDIF is untested and needs some work still (LED stays off)
44 * - 32 bit audio playback failed last time i tried but that might an AC'97
45 * codec support problem.
46 * - 32 bit recording works but can't try out playing: see above.
47 * - no suspend/resume support yet.
48 * - multiple codecs are `supported' but not tested; the implemetation needs
49 * some cleaning up.
50 */
51
52 #include <sys/cdefs.h>
53 __KERNEL_RCSID(0, "$NetBSD: auixp.c,v 1.41.2.2 2017/08/28 17:52:05 skrll Exp $");
54
55 #include <sys/types.h>
56 #include <sys/errno.h>
57 #include <sys/null.h>
58 #include <sys/param.h>
59 #include <sys/systm.h>
60 #include <sys/kmem.h>
61 #include <sys/device.h>
62 #include <sys/conf.h>
63 #include <sys/exec.h>
64 #include <sys/select.h>
65 #include <sys/audioio.h>
66 #include <sys/queue.h>
67 #include <sys/bus.h>
68 #include <sys/intr.h>
69
70 #include <dev/audio_if.h>
71 #include <dev/mulaw.h>
72 #include <dev/auconv.h>
73
74 #include <dev/ic/ac97var.h>
75 #include <dev/ic/ac97reg.h>
76
77 #include <dev/pci/pcidevs.h>
78 #include <dev/pci/pcivar.h>
79 #include <dev/pci/auixpreg.h>
80 #include <dev/pci/auixpvar.h>
81
82
83 /* #define DEBUG_AUIXP */
84
85
86 /* why isn't this base address register not in the headerfile? */
87 #define PCI_CBIO 0x10
88
89
90 /* macro's used */
91 #define KERNADDR(p) ((void *)((p)->addr))
92 #define DMAADDR(p) ((p)->map->dm_segs[0].ds_addr)
93
94
95 /* the differences might be irrelevant */
96 enum {
97 IXP_200,
98 IXP_300,
99 IXP_400
100 };
101
102
103 /* our `cards' */
104 static const struct auixp_card_type {
105 uint16_t pci_vendor_id;
106 uint16_t pci_product_id;
107 int type;
108 } auixp_card_types[] = {
109 { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_200, IXP_200 },
110 { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_300, IXP_300 },
111 { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_400, IXP_400 },
112 { 0, 0, 0 }
113 };
114
115
116 struct audio_device auixp_device = {
117 "ATI IXP audio",
118 "",
119 "auixp"
120 };
121
122
123 /* codec detection constant indicating the interrupt flags */
124 #define ALL_CODECS_NOT_READY \
125 (ATI_REG_ISR_CODEC0_NOT_READY |\
126 ATI_REG_ISR_CODEC1_NOT_READY |\
127 ATI_REG_ISR_CODEC2_NOT_READY)
128 #define CODEC_CHECK_BITS (ALL_CODECS_NOT_READY|ATI_REG_ISR_NEW_FRAME)
129
130
131 /* autoconfig */
132 static int auixp_match(device_t, cfdata_t, void *);
133 static void auixp_attach(device_t, device_t, void *);
134 static int auixp_detach(device_t, int);
135
136
137 /* audio(9) function prototypes */
138 static int auixp_query_encoding(void *, struct audio_encoding *);
139 static int auixp_set_params(void *, int, int, audio_params_t *,
140 audio_params_t *,
141 stream_filter_list_t *, stream_filter_list_t *);
142 static int auixp_commit_settings(void *);
143 static int auixp_round_blocksize(void *, int, int, const audio_params_t *);
144 static int auixp_trigger_output(void *, void *, void *, int,
145 void (*)(void *),
146 void *, const audio_params_t *);
147 static int auixp_trigger_input(void *, void *, void *, int,
148 void (*)(void *),
149 void *, const audio_params_t *);
150 static int auixp_halt_output(void *);
151 static int auixp_halt_input(void *);
152 static int auixp_set_port(void *, mixer_ctrl_t *);
153 static int auixp_get_port(void *, mixer_ctrl_t *);
154 static int auixp_query_devinfo(void *, mixer_devinfo_t *);
155 static void * auixp_malloc(void *, int, size_t);
156 static void auixp_free(void *, void *, size_t);
157 static int auixp_getdev(void *, struct audio_device *);
158 static size_t auixp_round_buffersize(void *, int, size_t);
159 static int auixp_get_props(void *);
160 static int auixp_intr(void *);
161 static int auixp_allocmem(struct auixp_softc *, size_t, size_t,
162 struct auixp_dma *);
163 static int auixp_freemem(struct auixp_softc *, struct auixp_dma *);
164 static paddr_t auixp_mappage(void *, void *, off_t, int);
165
166 /* Supporting subroutines */
167 static int auixp_init(struct auixp_softc *);
168 static void auixp_autodetect_codecs(struct auixp_softc *);
169 static void auixp_post_config(device_t);
170
171 static void auixp_reset_aclink(struct auixp_softc *);
172 static int auixp_attach_codec(void *, struct ac97_codec_if *);
173 static int auixp_read_codec(void *, uint8_t, uint16_t *);
174 static int auixp_write_codec(void *, uint8_t, uint16_t);
175 static int auixp_wait_for_codecs(struct auixp_softc *, const char *);
176 static int auixp_reset_codec(void *);
177 static enum ac97_host_flags auixp_flags_codec(void *);
178
179 static void auixp_enable_dma(struct auixp_softc *, struct auixp_dma *);
180 static void auixp_disable_dma(struct auixp_softc *, struct auixp_dma *);
181 static void auixp_enable_interrupts(struct auixp_softc *);
182 static void auixp_disable_interrupts(struct auixp_softc *);
183
184
185 /* statics */
186 static void auixp_link_daisychain(struct auixp_softc *,
187 struct auixp_dma *, struct auixp_dma *,
188 int, int);
189 static int auixp_allocate_dma_chain(struct auixp_softc *,
190 struct auixp_dma **);
191 static void auixp_program_dma_chain(struct auixp_softc *,
192 struct auixp_dma *);
193 static void auixp_dma_update(struct auixp_softc *, struct auixp_dma *);
194 static void auixp_update_busbusy(struct auixp_softc *);
195 static void auixp_get_locks(void *, kmutex_t **, kmutex_t **);
196
197 static bool auixp_resume(device_t, const pmf_qual_t *);
198
199
200 #ifdef DEBUG_AUIXP
201 static struct auixp_softc *static_sc;
202 static void auixp_dumpreg(void);
203 # define DPRINTF(x) printf x;
204 #else
205 # define DPRINTF(x)
206 #endif
207
208
209 static const struct audio_hw_if auixp_hw_if = {
210 NULL, /* open */
211 NULL, /* close */
212 NULL, /* drain */
213 auixp_query_encoding,
214 auixp_set_params,
215 auixp_round_blocksize,
216 auixp_commit_settings,
217 NULL, /* init_output */
218 NULL, /* init_input */
219 NULL, /* start_output */
220 NULL, /* start_input */
221 auixp_halt_output,
222 auixp_halt_input,
223 NULL, /* speaker_ctl */
224 auixp_getdev,
225 NULL, /* getfd */
226 auixp_set_port,
227 auixp_get_port,
228 auixp_query_devinfo,
229 auixp_malloc,
230 auixp_free,
231 auixp_round_buffersize,
232 auixp_mappage,
233 auixp_get_props,
234 auixp_trigger_output,
235 auixp_trigger_input,
236 NULL, /* dev_ioctl */
237 auixp_get_locks,
238 };
239
240
241 CFATTACH_DECL_NEW(auixp, sizeof(struct auixp_softc), auixp_match, auixp_attach,
242 auixp_detach, NULL);
243
244
245 /*
246 * audio(9) functions
247 */
248
249 static int
250 auixp_query_encoding(void *hdl, struct audio_encoding *ae)
251 {
252 struct auixp_codec *co;
253 struct auixp_softc *sc;
254
255 co = (struct auixp_codec *) hdl;
256 sc = co->sc;
257 return auconv_query_encoding(sc->sc_encodings, ae);
258 }
259
260
261 static int
262 auixp_set_rate(struct auixp_codec *co, int mode, u_int srate)
263 {
264 int ret;
265 u_int ratetmp;
266
267 ratetmp = srate;
268 if (mode == AUMODE_RECORD) {
269 ret = co->codec_if->vtbl->set_rate(co->codec_if,
270 AC97_REG_PCM_LR_ADC_RATE, &ratetmp);
271 return ret;
272 }
273
274 /* play mode */
275 ret = co->codec_if->vtbl->set_rate(co->codec_if,
276 AC97_REG_PCM_FRONT_DAC_RATE, &ratetmp);
277 if (ret)
278 return ret;
279
280 ratetmp = srate;
281 ret = co->codec_if->vtbl->set_rate(co->codec_if,
282 AC97_REG_PCM_SURR_DAC_RATE, &ratetmp);
283 if (ret)
284 return ret;
285
286 ratetmp = srate;
287 ret = co->codec_if->vtbl->set_rate(co->codec_if,
288 AC97_REG_PCM_LFE_DAC_RATE, &ratetmp);
289 return ret;
290 }
291
292
293 /* commit setting and program ATI IXP chip */
294 static int
295 auixp_commit_settings(void *hdl)
296 {
297 struct auixp_codec *co;
298 struct auixp_softc *sc;
299 bus_space_tag_t iot;
300 bus_space_handle_t ioh;
301 struct audio_params *params;
302 uint32_t value;
303
304 /* XXX would it be better to stop interrupts first? XXX */
305 co = (struct auixp_codec *) hdl;
306 sc = co->sc;
307 iot = sc->sc_iot;
308 ioh = sc->sc_ioh;
309
310 /* process input settings */
311 params = &sc->sc_play_params;
312
313 /* set input interleaving (precision) */
314 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
315 value &= ~ATI_REG_CMD_INTERLEAVE_IN;
316 if (params->precision <= 16)
317 value |= ATI_REG_CMD_INTERLEAVE_IN;
318 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
319
320 /* process output settings */
321 params = &sc->sc_play_params;
322
323 value = bus_space_read_4(iot, ioh, ATI_REG_OUT_DMA_SLOT);
324 value &= ~ATI_REG_OUT_DMA_SLOT_MASK;
325
326 /* TODO SPDIF case for 8 channels */
327 switch (params->channels) {
328 case 6:
329 value |= ATI_REG_OUT_DMA_SLOT_BIT(7) |
330 ATI_REG_OUT_DMA_SLOT_BIT(8);
331 /* fallthru */
332 case 4:
333 value |= ATI_REG_OUT_DMA_SLOT_BIT(6) |
334 ATI_REG_OUT_DMA_SLOT_BIT(9);
335 /* fallthru */
336 default:
337 value |= ATI_REG_OUT_DMA_SLOT_BIT(3) |
338 ATI_REG_OUT_DMA_SLOT_BIT(4);
339 break;
340 }
341 /* set output threshold */
342 value |= 0x04 << ATI_REG_OUT_DMA_THRESHOLD_SHIFT;
343 bus_space_write_4(iot, ioh, ATI_REG_OUT_DMA_SLOT, value);
344
345 /* set output interleaving (precision) */
346 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
347 value &= ~ATI_REG_CMD_INTERLEAVE_OUT;
348 if (params->precision <= 16)
349 value |= ATI_REG_CMD_INTERLEAVE_OUT;
350 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
351
352 /* enable 6 channel reordering */
353 value = bus_space_read_4(iot, ioh, ATI_REG_6CH_REORDER);
354 value &= ~ATI_REG_6CH_REORDER_EN;
355 if (params->channels == 6)
356 value |= ATI_REG_6CH_REORDER_EN;
357 bus_space_write_4(iot, ioh, ATI_REG_6CH_REORDER, value);
358
359 if (sc->has_spdif) {
360 /* set SPDIF (if present) */
361 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
362 value &= ~ATI_REG_CMD_SPDF_CONFIG_MASK;
363 value |= ATI_REG_CMD_SPDF_CONFIG_34; /* NetBSD AC'97 default */
364
365 /* XXX this prolly is not nessisary unless splitted XXX */
366 value &= ~ATI_REG_CMD_INTERLEAVE_SPDF;
367 if (params->precision <= 16)
368 value |= ATI_REG_CMD_INTERLEAVE_SPDF;
369 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
370 }
371
372 return 0;
373 }
374
375
376 /* set audio properties in desired setting */
377 static int
378 auixp_set_params(void *hdl, int setmode, int usemode,
379 audio_params_t *play, audio_params_t *rec, stream_filter_list_t *pfil,
380 stream_filter_list_t *rfil)
381 {
382 struct auixp_codec *co;
383 struct auixp_softc *sc;
384 audio_params_t *params;
385 stream_filter_list_t *fil;
386 int mode, index;
387
388 /*
389 * In current NetBSD AC'97 implementation, SPDF is linked to channel 3
390 * and 4 i.e. stereo output.
391 */
392
393 co = (struct auixp_codec *) hdl;
394 sc = co->sc;
395 for (mode = AUMODE_RECORD; mode != -1;
396 mode = (mode == AUMODE_RECORD) ? AUMODE_PLAY : -1) {
397 if ((setmode & mode) == 0)
398 continue;
399
400 params = (mode == AUMODE_PLAY) ? play : rec;
401 fil = (mode == AUMODE_PLAY) ? pfil : rfil;
402 if (params == NULL)
403 continue;
404
405 /* AD1888 settings ... don't know the IXP limits */
406 if (params->sample_rate < AUIXP_MINRATE)
407 return EINVAL;
408 if (params->sample_rate > AUIXP_MAXRATE)
409 return EINVAL;
410
411 index = auconv_set_converter(sc->sc_formats, AUIXP_NFORMATS,
412 mode, params, TRUE, fil);
413
414 /* nothing found? */
415 if (index < 0)
416 return EINVAL;
417
418 /* not sure yet as to why i have to change params here */
419 if (fil->req_size > 0)
420 params = &fil->filters[0].param;
421
422 /* if variable speed and we can't set the desired rate, fail */
423 if ((sc->sc_formats[index].frequency_type != 1) &&
424 auixp_set_rate(co, mode, params->sample_rate))
425 return EINVAL;
426
427 /* preserve the settings */
428 if (mode == AUMODE_PLAY)
429 sc->sc_play_params = *params;
430 if (mode == AUMODE_RECORD)
431 sc->sc_rec_params = *params;
432 }
433
434 return 0;
435 }
436
437
438 /* called to translate a requested blocksize to a hw-possible one */
439 static int
440 auixp_round_blocksize(void *hdl, int bs, int mode,
441 const audio_params_t *param)
442 {
443 uint32_t new_bs;
444
445 new_bs = bs;
446 /* Be conservative; align to 32 bytes and maximise it to 64 kb */
447 /* 256 kb possible */
448 if (new_bs > 0x10000)
449 bs = 0x10000; /* 64 kb max */
450 new_bs = (bs & ~0x20); /* 32 bytes align */
451
452 return new_bs;
453 }
454
455
456 /*
457 * allocate dma capable memory and record its information for later retrieval
458 * when we program the dma chain itself. The trigger routines passes on the
459 * kernel virtual address we return here as a reference to the mapping.
460 */
461 static void *
462 auixp_malloc(void *hdl, int direction, size_t size)
463 {
464 struct auixp_codec *co;
465 struct auixp_softc *sc;
466 struct auixp_dma *dma;
467 int error;
468
469 co = (struct auixp_codec *) hdl;
470 sc = co->sc;
471 /* get us a auixp_dma structure */
472 dma = kmem_alloc(sizeof(*dma), KM_SLEEP);
473
474 /* get us a dma buffer itself */
475 error = auixp_allocmem(sc, size, 16, dma);
476 if (error) {
477 kmem_free(dma, sizeof(*dma));
478 aprint_error_dev(sc->sc_dev, "auixp_malloc: not enough memory\n");
479
480 return NULL;
481 }
482 SLIST_INSERT_HEAD(&sc->sc_dma_list, dma, dma_chain);
483
484 DPRINTF(("auixp_malloc: returning kern %p, hw 0x%08x for %d bytes "
485 "in %d segs\n", KERNADDR(dma), (uint32_t) DMAADDR(dma), dma->size,
486 dma->nsegs)
487 );
488
489 return KERNADDR(dma);
490 }
491
492
493 /*
494 * free and release dma capable memory we allocated before and remove its
495 * recording
496 */
497 static void
498 auixp_free(void *hdl, void *addr, size_t size)
499 {
500 struct auixp_codec *co;
501 struct auixp_softc *sc;
502 struct auixp_dma *dma;
503
504 co = (struct auixp_codec *) hdl;
505 sc = co->sc;
506 SLIST_FOREACH(dma, &sc->sc_dma_list, dma_chain) {
507 if (KERNADDR(dma) == addr) {
508 SLIST_REMOVE(&sc->sc_dma_list, dma, auixp_dma,
509 dma_chain);
510 auixp_freemem(sc, dma);
511 kmem_free(dma, sizeof(*dma));
512 return;
513 }
514 }
515 }
516
517
518 static int
519 auixp_getdev(void *hdl, struct audio_device *ret)
520 {
521
522 *ret = auixp_device;
523 return 0;
524 }
525
526
527 /* pass request to AC'97 codec code */
528 static int
529 auixp_set_port(void *hdl, mixer_ctrl_t *mc)
530 {
531 struct auixp_codec *co;
532
533 co = (struct auixp_codec *) hdl;
534 return co->codec_if->vtbl->mixer_set_port(co->codec_if, mc);
535 }
536
537
538 /* pass request to AC'97 codec code */
539 static int
540 auixp_get_port(void *hdl, mixer_ctrl_t *mc)
541 {
542 struct auixp_codec *co;
543
544 co = (struct auixp_codec *) hdl;
545 return co->codec_if->vtbl->mixer_get_port(co->codec_if, mc);
546 }
547
548 /* pass request to AC'97 codec code */
549 static int
550 auixp_query_devinfo(void *hdl, mixer_devinfo_t *di)
551 {
552 struct auixp_codec *co;
553
554 co = (struct auixp_codec *) hdl;
555 return co->codec_if->vtbl->query_devinfo(co->codec_if, di);
556 }
557
558
559 static size_t
560 auixp_round_buffersize(void *hdl, int direction,
561 size_t bufsize)
562 {
563
564 /* XXX force maximum? i.e. 256 kb? */
565 return bufsize;
566 }
567
568
569 static int
570 auixp_get_props(void *hdl)
571 {
572
573 return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
574 }
575
576
577 /*
578 * A dma descriptor has dma->nsegs segments defined in dma->segs set up when
579 * we claimed the memory.
580 *
581 * Due to our demand for one contiguous DMA area, we only have one segment. A
582 * c_dma structure is about 3 kb for the 256 entries we maximally program
583 * -arbitrary limit AFAIK- so all is most likely to be in one segment/page
584 * anyway.
585 *
586 * XXX ought to implement fragmented dma area XXX
587 *
588 * Note that _v variables depict kernel virtual addresses, _p variables depict
589 * physical addresses.
590 */
591 static void
592 auixp_link_daisychain(struct auixp_softc *sc,
593 struct auixp_dma *c_dma, struct auixp_dma *s_dma,
594 int blksize, int blocks)
595 {
596 atiixp_dma_desc_t *caddr_v, *next_caddr_v;
597 uint32_t caddr_p, next_caddr_p, saddr_p;
598 int i;
599
600 /* just make sure we are not changing when its running */
601 auixp_disable_dma(sc, c_dma);
602
603 /* setup dma chain start addresses */
604 caddr_v = KERNADDR(c_dma);
605 caddr_p = DMAADDR(c_dma);
606 saddr_p = DMAADDR(s_dma);
607
608 /* program the requested number of blocks */
609 for (i = 0; i < blocks; i++) {
610 /* clear the block just in case */
611 memset(caddr_v, 0, sizeof(atiixp_dma_desc_t));
612
613 /* round robin the chain dma addresses for its successor */
614 next_caddr_v = caddr_v + 1;
615 next_caddr_p = caddr_p + sizeof(atiixp_dma_desc_t);
616
617 if (i == blocks-1) {
618 next_caddr_v = KERNADDR(c_dma);
619 next_caddr_p = DMAADDR(c_dma);
620 }
621
622 /* fill in the hardware dma chain descriptor in little-endian */
623 caddr_v->addr = htole32(saddr_p);
624 caddr_v->status = htole16(0);
625 caddr_v->size = htole16((blksize >> 2)); /* in dwords (!!!) */
626 caddr_v->next = htole32(next_caddr_p);
627
628 /* advance slot */
629 saddr_p += blksize; /* XXX assuming contiguous XXX */
630 caddr_v = next_caddr_v;
631 caddr_p = next_caddr_p;
632 }
633 }
634
635
636 static int
637 auixp_allocate_dma_chain(struct auixp_softc *sc, struct auixp_dma **dmap)
638 {
639 struct auixp_dma *dma;
640 int error;
641
642 /* allocate keeper of dma area */
643 *dmap = NULL;
644 dma = kmem_zalloc(sizeof(struct auixp_dma), KM_SLEEP);
645
646 /* allocate for daisychain of IXP hardware-dma descriptors */
647 error = auixp_allocmem(sc, DMA_DESC_CHAIN * sizeof(atiixp_dma_desc_t),
648 16, dma);
649 if (error) {
650 aprint_error_dev(sc->sc_dev, "can't malloc dma descriptor chain\n");
651 kmem_free(dma, sizeof(*dma));
652 return ENOMEM;
653 }
654
655 /* return info and initialise structure */
656 dma->intr = NULL;
657 dma->intrarg = NULL;
658
659 *dmap = dma;
660 return 0;
661 }
662
663
664 /* program dma chain in its link address descriptor */
665 static void
666 auixp_program_dma_chain(struct auixp_softc *sc, struct auixp_dma *dma)
667 {
668 bus_space_tag_t iot;
669 bus_space_handle_t ioh;
670 uint32_t value;
671
672 iot = sc->sc_iot;
673 ioh = sc->sc_ioh;
674 /* get hardware start address of DMA chain and set valid-flag in it */
675 /* XXX always at start? XXX */
676 value = DMAADDR(dma);
677 value = value | ATI_REG_LINKPTR_EN;
678
679 /* reset linkpointer */
680 bus_space_write_4(iot, ioh, dma->linkptr, 0);
681
682 /* reset this DMA engine */
683 auixp_disable_dma(sc, dma);
684 auixp_enable_dma(sc, dma);
685
686 /* program new DMA linkpointer */
687 bus_space_write_4(iot, ioh, dma->linkptr, value);
688 }
689
690
691 /* called from interrupt code to signal end of one dma-slot */
692 static void
693 auixp_dma_update(struct auixp_softc *sc, struct auixp_dma *dma)
694 {
695
696 /* be very paranoid */
697 if (!dma)
698 panic("%s: update: dma = NULL", device_xname(sc->sc_dev));
699 if (!dma->intr)
700 panic("%s: update: dma->intr = NULL", device_xname(sc->sc_dev));
701
702 /* request more input from upper layer */
703 (*dma->intr)(dma->intrarg);
704 }
705
706
707 /*
708 * The magic `busbusy' bit that needs to be set when dma is active; allowing
709 * busmastering?
710 */
711 static void
712 auixp_update_busbusy(struct auixp_softc *sc)
713 {
714 bus_space_tag_t iot;
715 bus_space_handle_t ioh;
716 uint32_t value;
717 int running;
718
719 iot = sc->sc_iot;
720 ioh = sc->sc_ioh;
721 /* set bus-busy flag when either recording or playing is performed */
722 value = bus_space_read_4(iot, ioh, ATI_REG_IER);
723 value &= ~ATI_REG_IER_SET_BUS_BUSY;
724
725 running = ((sc->sc_output_dma->running) || (sc->sc_input_dma->running));
726 if (running)
727 value |= ATI_REG_IER_SET_BUS_BUSY;
728
729 bus_space_write_4(iot, ioh, ATI_REG_IER, value);
730
731 }
732
733
734 /*
735 * Called from upper audio layer to request playing audio, only called once;
736 * audio is refilled by calling the intr() function when space is available
737 * again.
738 */
739 /* XXX allmost literaly a copy of trigger-input; could be factorised XXX */
740 static int
741 auixp_trigger_output(void *hdl, void *start, void *end, int blksize,
742 void (*intr)(void *), void *intrarg, const audio_params_t *param)
743 {
744 struct auixp_codec *co;
745 struct auixp_softc *sc;
746 struct auixp_dma *chain_dma;
747 struct auixp_dma *sound_dma;
748 uint32_t blocks;
749
750 co = (struct auixp_codec *) hdl;
751 sc = co->sc;
752 chain_dma = sc->sc_output_dma;
753 /* add functions to call back */
754 chain_dma->intr = intr;
755 chain_dma->intrarg = intrarg;
756
757 /*
758 * Program output DMA chain with blocks from [start...end] with
759 * blksize fragments.
760 *
761 * NOTE, we can assume its in one block since we asked for it to be in
762 * one contiguous blob; XXX change this? XXX
763 */
764 blocks = (size_t) (((char *) end) - ((char *) start)) / blksize;
765
766 /* lookup `start' address in our list of DMA area's */
767 SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) {
768 if (KERNADDR(sound_dma) == start)
769 break;
770 }
771
772 /* not ours ? then bail out */
773 if (!sound_dma) {
774 printf("%s: auixp_trigger_output: bad sound addr %p\n",
775 device_xname(sc->sc_dev), start);
776 return EINVAL;
777 }
778
779 /* link round-robin daisychain and program hardware */
780 auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks);
781 auixp_program_dma_chain(sc, chain_dma);
782
783 /* mark we are now able to run now */
784 chain_dma->running = 1;
785
786 /* update bus-flags; XXX programs more flags XXX */
787 auixp_update_busbusy(sc);
788
789 /* callbacks happen in interrupt routine */
790 return 0;
791 }
792
793
794 /* halt output of audio, just disable its dma and update bus state */
795 static int
796 auixp_halt_output(void *hdl)
797 {
798 struct auixp_codec *co;
799 struct auixp_softc *sc;
800 struct auixp_dma *dma;
801
802 co = (struct auixp_codec *) hdl;
803 sc = co->sc;
804 dma = sc->sc_output_dma;
805 auixp_disable_dma(sc, dma);
806
807 dma->running = 0;
808 auixp_update_busbusy(sc);
809
810 return 0;
811 }
812
813
814 /* XXX allmost literaly a copy of trigger-output; could be factorised XXX */
815 static int
816 auixp_trigger_input(void *hdl, void *start, void *end, int blksize,
817 void (*intr)(void *), void *intrarg, const audio_params_t *param)
818 {
819 struct auixp_codec *co;
820 struct auixp_softc *sc;
821 struct auixp_dma *chain_dma;
822 struct auixp_dma *sound_dma;
823 uint32_t blocks;
824
825 co = (struct auixp_codec *) hdl;
826 sc = co->sc;
827 chain_dma = sc->sc_input_dma;
828 /* add functions to call back */
829 chain_dma->intr = intr;
830 chain_dma->intrarg = intrarg;
831
832 /*
833 * Program output DMA chain with blocks from [start...end] with
834 * blksize fragments.
835 *
836 * NOTE, we can assume its in one block since we asked for it to be in
837 * one contiguous blob; XXX change this? XXX
838 */
839 blocks = (size_t) (((char *) end) - ((char *) start)) / blksize;
840
841 /* lookup `start' address in our list of DMA area's */
842 SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) {
843 if (KERNADDR(sound_dma) == start)
844 break;
845 }
846
847 /* not ours ? then bail out */
848 if (!sound_dma) {
849 printf("%s: auixp_trigger_input: bad sound addr %p\n",
850 device_xname(sc->sc_dev), start);
851 return EINVAL;
852 }
853
854 /* link round-robin daisychain and program hardware */
855 auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks);
856 auixp_program_dma_chain(sc, chain_dma);
857
858 /* mark we are now able to run now */
859 chain_dma->running = 1;
860
861 /* update bus-flags; XXX programs more flags XXX */
862 auixp_update_busbusy(sc);
863
864 /* callbacks happen in interrupt routine */
865 return 0;
866 }
867
868
869 /* halt sampling audio, just disable its dma and update bus state */
870 static int
871 auixp_halt_input(void *hdl)
872 {
873 struct auixp_codec *co;
874 struct auixp_softc *sc;
875 struct auixp_dma *dma;
876
877 co = (struct auixp_codec *) hdl;
878 sc = co->sc;
879 dma = sc->sc_input_dma;
880 auixp_disable_dma(sc, dma);
881
882 dma->running = 0;
883 auixp_update_busbusy(sc);
884
885 return 0;
886 }
887
888
889 /*
890 * IXP audio interrupt handler
891 *
892 * note that we return the number of bits handled; the return value is not
893 * documentated but i saw it implemented in other drivers. Prolly returning a
894 * value > 0 means "i've dealt with it"
895 *
896 */
897 static int
898 auixp_intr(void *softc)
899 {
900 struct auixp_softc *sc;
901 bus_space_tag_t iot;
902 bus_space_handle_t ioh;
903 uint32_t status, enable, detected_codecs;
904 int ret;
905
906 sc = softc;
907 mutex_spin_enter(&sc->sc_intr_lock);
908
909 iot = sc->sc_iot;
910 ioh = sc->sc_ioh;
911 ret = 0;
912 /* get status from the interrupt status register */
913 status = bus_space_read_4(iot, ioh, ATI_REG_ISR);
914
915 if (status == 0) {
916 mutex_spin_exit(&sc->sc_intr_lock);
917 return 0;
918 }
919
920 DPRINTF(("%s: (status = %x)\n", device_xname(sc->sc_dev), status));
921
922 /* check DMA UPDATE flags for input & output */
923 if (status & ATI_REG_ISR_IN_STATUS) {
924 ret++; DPRINTF(("IN_STATUS\n"));
925 auixp_dma_update(sc, sc->sc_input_dma);
926 }
927 if (status & ATI_REG_ISR_OUT_STATUS) {
928 ret++; DPRINTF(("OUT_STATUS\n"));
929 auixp_dma_update(sc, sc->sc_output_dma);
930 }
931
932 /* XXX XRUN flags not used/needed yet; should i implement it? XXX */
933 /* acknowledge the interrupts nevertheless */
934 if (status & ATI_REG_ISR_IN_XRUN) {
935 ret++; DPRINTF(("IN_XRUN\n"));
936 /* auixp_dma_xrun(sc, sc->sc_input_dma); */
937 }
938 if (status & ATI_REG_ISR_OUT_XRUN) {
939 ret++; DPRINTF(("OUT_XRUN\n"));
940 /* auixp_dma_xrun(sc, sc->sc_output_dma); */
941 }
942
943 /* check if we are looking for codec detection */
944 if (status & CODEC_CHECK_BITS) {
945 ret++;
946 /* mark missing codecs as not ready */
947 detected_codecs = status & CODEC_CHECK_BITS;
948 sc->sc_codec_not_ready_bits |= detected_codecs;
949
950 /* disable detected interrupt sources */
951 enable = bus_space_read_4(iot, ioh, ATI_REG_IER);
952 enable &= ~detected_codecs;
953 bus_space_write_4(iot, ioh, ATI_REG_IER, enable);
954 }
955
956 /* acknowledge interrupt sources */
957 bus_space_write_4(iot, ioh, ATI_REG_ISR, status);
958
959 mutex_spin_exit(&sc->sc_intr_lock);
960 return ret;
961 }
962
963
964 /* allocate memory for dma purposes; on failure of any of the steps, roll back */
965 static int
966 auixp_allocmem(struct auixp_softc *sc, size_t size,
967 size_t align, struct auixp_dma *dma)
968 {
969 int error;
970
971 /* remember size */
972 dma->size = size;
973
974 /* allocate DMA safe memory but in just one segment for now :( */
975 error = bus_dmamem_alloc(sc->sc_dmat, dma->size, align, 0,
976 dma->segs, sizeof(dma->segs) / sizeof(dma->segs[0]), &dma->nsegs,
977 BUS_DMA_WAITOK);
978 if (error)
979 return error;
980
981 /*
982 * map allocated memory into kernel virtual address space and keep it
983 * coherent with the CPU.
984 */
985 error = bus_dmamem_map(sc->sc_dmat, dma->segs, dma->nsegs, dma->size,
986 &dma->addr, BUS_DMA_WAITOK | BUS_DMA_COHERENT);
987 if (error)
988 goto free;
989
990 /* allocate associated dma handle and initialize it. */
991 error = bus_dmamap_create(sc->sc_dmat, dma->size, 1, dma->size, 0,
992 BUS_DMA_WAITOK, &dma->map);
993 if (error)
994 goto unmap;
995
996 /*
997 * load the dma handle with mappings for a dma transfer; all pages
998 * need to be wired.
999 */
1000 error = bus_dmamap_load(sc->sc_dmat, dma->map, dma->addr, dma->size, NULL,
1001 BUS_DMA_WAITOK);
1002 if (error)
1003 goto destroy;
1004
1005 return 0;
1006
1007 destroy:
1008 bus_dmamap_destroy(sc->sc_dmat, dma->map);
1009 unmap:
1010 bus_dmamem_unmap(sc->sc_dmat, dma->addr, dma->size);
1011 free:
1012 bus_dmamem_free(sc->sc_dmat, dma->segs, dma->nsegs);
1013
1014 return error;
1015 }
1016
1017
1018 /* undo dma mapping and release memory allocated */
1019 static int
1020 auixp_freemem(struct auixp_softc *sc, struct auixp_dma *p)
1021 {
1022
1023 bus_dmamap_unload(sc->sc_dmat, p->map);
1024 bus_dmamap_destroy(sc->sc_dmat, p->map);
1025 bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
1026 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
1027
1028 return 0;
1029 }
1030
1031
1032 /* memory map dma memory */
1033 static paddr_t
1034 auixp_mappage(void *hdl, void *mem, off_t off, int prot)
1035 {
1036 struct auixp_codec *co;
1037 struct auixp_softc *sc;
1038 struct auixp_dma *p;
1039
1040 co = (struct auixp_codec *) hdl;
1041 sc = co->sc;
1042 /* for sanity */
1043 if (off < 0)
1044 return -1;
1045
1046 /* look up allocated DMA area */
1047 SLIST_FOREACH(p, &sc->sc_dma_list, dma_chain) {
1048 if (KERNADDR(p) == mem)
1049 break;
1050 }
1051
1052 /* have we found it ? */
1053 if (!p)
1054 return -1;
1055
1056 /* return mmap'd region */
1057 return bus_dmamem_mmap(sc->sc_dmat, p->segs, p->nsegs,
1058 off, prot, BUS_DMA_WAITOK);
1059 }
1060
1061
1062 /*
1063 * Attachment section
1064 */
1065
1066 /* Is it my hardware? */
1067 static int
1068 auixp_match(device_t dev, cfdata_t match, void *aux)
1069 {
1070 struct pci_attach_args *pa;
1071
1072 pa = (struct pci_attach_args *)aux;
1073 switch(PCI_VENDOR(pa->pa_id)) {
1074 case PCI_VENDOR_ATI:
1075 switch(PCI_PRODUCT(pa->pa_id)) {
1076 case PCI_PRODUCT_ATI_IXP_AUDIO_200:
1077 case PCI_PRODUCT_ATI_IXP_AUDIO_300:
1078 case PCI_PRODUCT_ATI_IXP_AUDIO_400:
1079 return 1;
1080 }
1081 }
1082
1083 return 0;
1084 }
1085
1086
1087 /* it is... now hook up and set up the resources we need */
1088 static void
1089 auixp_attach(device_t parent, device_t self, void *aux)
1090 {
1091 struct auixp_softc *sc;
1092 struct pci_attach_args *pa;
1093 pcitag_t tag;
1094 pci_chipset_tag_t pc;
1095 pci_intr_handle_t ih;
1096 const struct auixp_card_type *card;
1097 const char *intrstr;
1098 uint32_t data;
1099 int error;
1100 char intrbuf[PCI_INTRSTR_LEN];
1101
1102 sc = device_private(self);
1103 sc->sc_dev = self;
1104 pa = (struct pci_attach_args *)aux;
1105 tag = pa->pa_tag;
1106 pc = pa->pa_pc;
1107 #ifdef DEBUG_AUIXP
1108 static_sc = sc;
1109 #endif
1110
1111 /* print information confirming attachment */
1112 pci_aprint_devinfo(pa, "Audio controller");
1113
1114 /* set up details from our set of known `cards'/chips */
1115 for (card = auixp_card_types; card->pci_vendor_id; card++)
1116 if (PCI_VENDOR(pa->pa_id) == card->pci_vendor_id &&
1117 PCI_PRODUCT(pa->pa_id) == card->pci_product_id) {
1118 sc->type = card->type;
1119 break;
1120 }
1121
1122 /* device only has 32 bit non prefetchable memory */
1123 /* set MEM space access and enable the card's busmastering */
1124 data = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
1125 data |= (PCI_COMMAND_MEM_ENABLE | PCI_COMMAND_MASTER_ENABLE);
1126 pci_conf_write(pc, tag, PCI_COMMAND_STATUS_REG, data);
1127
1128 /* map memory; its not sized -> what is the size? max PCI slot size? */
1129 if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_MEM, 0,
1130 &sc->sc_iot, &sc->sc_ioh, &sc->sc_iob, &sc->sc_ios)) {
1131 aprint_error_dev(sc->sc_dev, "can't map memory space\n");
1132 return;
1133 }
1134
1135 /* Initialize softc */
1136 sc->sc_tag = tag;
1137 sc->sc_pct = pc;
1138 sc->sc_dmat = pa->pa_dmat;
1139 SLIST_INIT(&sc->sc_dma_list);
1140
1141 /* get us the auixp_dma structures */
1142 auixp_allocate_dma_chain(sc, &sc->sc_output_dma);
1143 auixp_allocate_dma_chain(sc, &sc->sc_input_dma);
1144
1145 /* when that fails we are dead in the water */
1146 if (!sc->sc_output_dma || !sc->sc_input_dma)
1147 return;
1148
1149 #if 0
1150 /* could preliminary program DMA chain */
1151 auixp_program_dma_chain(sc, sc->sc_output_dma);
1152 auixp_program_dma_chain(sc, sc->sc_input_dma);
1153 #endif
1154
1155 /* map interrupt on the pci bus */
1156 if (pci_intr_map(pa, &ih)) {
1157 aprint_error_dev(sc->sc_dev, "can't map interrupt\n");
1158 return;
1159 }
1160
1161 /* where are we connected at ? */
1162 intrstr = pci_intr_string(pc, ih, intrbuf, sizeof(intrbuf));
1163
1164 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
1165 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_AUDIO);
1166
1167 /* establish interrupt routine hookup at IPL_AUDIO level */
1168 sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, auixp_intr, self);
1169 if (sc->sc_ih == NULL) {
1170 aprint_error_dev(sc->sc_dev, "can't establish interrupt");
1171 if (intrstr != NULL)
1172 aprint_error(" at %s", intrstr);
1173 aprint_error("\n");
1174 return;
1175 }
1176 aprint_normal_dev(sc->sc_dev, "interrupting at %s\n", intrstr);
1177
1178 /* power up chip */
1179 if ((error = pci_activate(pa->pa_pc, pa->pa_tag, self,
1180 pci_activate_null)) && error != EOPNOTSUPP) {
1181 aprint_error_dev(sc->sc_dev, "cannot activate %d\n",
1182 error);
1183 return;
1184 }
1185
1186 /* init chip */
1187 if (auixp_init(sc) == -1) {
1188 aprint_error_dev(sc->sc_dev,
1189 "auixp_attach: unable to initialize the card\n");
1190 return;
1191 }
1192
1193 if (!pmf_device_register(self, NULL, auixp_resume))
1194 aprint_error_dev(self, "couldn't establish power handler\n");
1195
1196 /*
1197 * delay further configuration of codecs and audio after interrupts
1198 * are enabled.
1199 */
1200 config_interrupts(self, auixp_post_config);
1201 }
1202
1203
1204 /* called from autoconfigure system when interrupts are enabled */
1205 static void
1206 auixp_post_config(device_t self)
1207 {
1208 struct auixp_softc *sc;
1209 struct auixp_codec *codec;
1210 int codec_nr;
1211 int res, i;
1212
1213 sc = device_private(self);
1214 /* detect the AC97 codecs */
1215 auixp_autodetect_codecs(sc);
1216
1217 /* setup audio translation formats : following codec0 (!) */
1218 codec = &sc->sc_codec[0];
1219 if (!codec->present) {
1220 /* nothing??? then invalidate all formats */
1221 for (i = 0; i < AUIXP_NFORMATS; i++) {
1222 AUFMT_INVALIDATE(&sc->sc_formats[i]);
1223 }
1224 return;
1225 }
1226
1227 /* copy formats and invalidate entries not suitable for codec0 */
1228 memcpy(sc->sc_formats, auixp_formats, sizeof(auixp_formats));
1229 mutex_enter(&sc->sc_lock);
1230 sc->has_4ch = AC97_IS_4CH(codec->codec_if);
1231 sc->has_6ch = AC97_IS_6CH(codec->codec_if);
1232 sc->is_fixed = AC97_IS_FIXED_RATE(codec->codec_if);
1233 sc->has_spdif = AC97_HAS_SPDIF(codec->codec_if);
1234 mutex_exit(&sc->sc_lock);
1235
1236 for (i = 0; i < AUIXP_NFORMATS; i++) {
1237 if (sc->is_fixed) {
1238 sc->sc_formats[i].frequency_type = 1;
1239 sc->sc_formats[i].frequency[0] = 48000;
1240 }
1241 switch (sc->sc_formats[i].channels) {
1242 case 4 :
1243 if (sc->has_4ch)
1244 break;
1245 AUFMT_INVALIDATE(&sc->sc_formats[i]);
1246 break;
1247 case 6 :
1248 if (sc->has_6ch)
1249 break;
1250 AUFMT_INVALIDATE(&sc->sc_formats[i]);
1251 break;
1252 default :
1253 break;
1254 }
1255 }
1256
1257 /*
1258 * Create all encodings (and/or -translations) based on the formats
1259 * supported. */
1260 res = auconv_create_encodings(sc->sc_formats, AUIXP_NFORMATS,
1261 &sc->sc_encodings);
1262 if (res) {
1263 printf("%s: auconv_create_encodings failed; "
1264 "no attachments\n", device_xname(sc->sc_dev));
1265 return;
1266 }
1267
1268 if (sc->has_spdif) {
1269 aprint_normal_dev(sc->sc_dev, "codec spdif support detected but disabled "
1270 "for now\n");
1271 sc->has_spdif = 0;
1272 }
1273
1274 /* fill in the missing details about the dma channels. */
1275 /* for output */
1276 sc->sc_output_dma->linkptr = ATI_REG_OUT_DMA_LINKPTR;
1277 sc->sc_output_dma->dma_enable_bit = ATI_REG_CMD_OUT_DMA_EN |
1278 ATI_REG_CMD_SEND_EN;
1279 /* have spdif? then this too! XXX not seeing LED yet! XXX */
1280 if (sc->has_spdif)
1281 sc->sc_output_dma->dma_enable_bit |= ATI_REG_CMD_SPDF_OUT_EN;
1282
1283 /* and for input */
1284 sc->sc_input_dma->linkptr = ATI_REG_IN_DMA_LINKPTR;
1285 sc->sc_input_dma->dma_enable_bit = ATI_REG_CMD_IN_DMA_EN |
1286 ATI_REG_CMD_RECEIVE_EN;
1287
1288 /* attach audio devices for all detected codecs */
1289 /* XXX wise? look at other multiple-codec able chipsets XXX */
1290 for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) {
1291 codec = &sc->sc_codec[codec_nr];
1292 if (codec->present)
1293 audio_attach_mi(&auixp_hw_if, codec, sc->sc_dev);
1294 }
1295
1296 /* done! now enable all interrupts we can service */
1297 auixp_enable_interrupts(sc);
1298 }
1299
1300 static void
1301 auixp_enable_interrupts(struct auixp_softc *sc)
1302 {
1303 bus_space_tag_t iot;
1304 bus_space_handle_t ioh;
1305 uint32_t value;
1306
1307 iot = sc->sc_iot;
1308 ioh = sc->sc_ioh;
1309
1310 mutex_spin_enter(&sc->sc_intr_lock);
1311
1312 /* clear all pending */
1313 bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff);
1314
1315 /* enable all relevant interrupt sources we can handle */
1316 value = bus_space_read_4(iot, ioh, ATI_REG_IER);
1317
1318 value |= ATI_REG_IER_IO_STATUS_EN;
1319 #ifdef notyet
1320 value |= ATI_REG_IER_IN_XRUN_EN;
1321 value |= ATI_REG_IER_OUT_XRUN_EN;
1322
1323 value |= ATI_REG_IER_SPDIF_XRUN_EN;
1324 value |= ATI_REG_IER_SPDF_STATUS_EN;
1325 #endif
1326
1327 bus_space_write_4(iot, ioh, ATI_REG_IER, value);
1328
1329 mutex_spin_exit(&sc->sc_intr_lock);
1330 }
1331
1332
1333 static void
1334 auixp_disable_interrupts(struct auixp_softc *sc)
1335 {
1336 bus_space_tag_t iot;
1337 bus_space_handle_t ioh;
1338
1339 iot = sc->sc_iot;
1340 ioh = sc->sc_ioh;
1341
1342 mutex_spin_enter(&sc->sc_intr_lock);
1343
1344 /* disable all interrupt sources */
1345 bus_space_write_4(iot, ioh, ATI_REG_IER, 0);
1346
1347 /* clear all pending */
1348 bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff);
1349
1350 mutex_spin_exit(&sc->sc_intr_lock);
1351 }
1352
1353
1354 /* dismantle what we've set up by undoing setup */
1355 static int
1356 auixp_detach(device_t self, int flags)
1357 {
1358 struct auixp_softc *sc;
1359
1360 sc = device_private(self);
1361 /* XXX shouldn't we just reset the chip? XXX */
1362 /*
1363 * should we explicitly disable interrupt generation and acknowledge
1364 * what's left on? better be safe than sorry.
1365 */
1366 auixp_disable_interrupts(sc);
1367
1368 /* tear down .... */
1369 config_detach(sc->sc_dev, flags); /* XXX OK? XXX */
1370 pmf_device_deregister(self);
1371
1372 if (sc->sc_ih != NULL)
1373 pci_intr_disestablish(sc->sc_pct, sc->sc_ih);
1374 if (sc->sc_ios)
1375 bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
1376
1377 mutex_destroy(&sc->sc_lock);
1378 mutex_destroy(&sc->sc_intr_lock);
1379
1380 return 0;
1381 }
1382
1383
1384 /*
1385 * codec handling
1386 *
1387 * IXP audio support can have upto 3 codecs! are they chained ? or
1388 * alternative outlets with the same audio feed i.e. with different mixer
1389 * settings? XXX does NetBSD support more than one audio codec? XXX
1390 */
1391
1392
1393 static int
1394 auixp_attach_codec(void *aux, struct ac97_codec_if *codec_if)
1395 {
1396 struct auixp_codec *ixp_codec;
1397
1398 ixp_codec = aux;
1399 ixp_codec->codec_if = codec_if;
1400 ixp_codec->present = 1;
1401
1402 return 0;
1403 }
1404
1405
1406 static int
1407 auixp_read_codec(void *aux, uint8_t reg, uint16_t *result)
1408 {
1409 struct auixp_codec *co;
1410 struct auixp_softc *sc;
1411 bus_space_tag_t iot;
1412 bus_space_handle_t ioh;
1413 uint32_t data;
1414 int timeout;
1415
1416 co = aux;
1417 sc = co->sc;
1418 iot = sc->sc_iot;
1419 ioh = sc->sc_ioh;
1420 if (auixp_wait_for_codecs(sc, "read_codec"))
1421 return 0xffff;
1422
1423 /* build up command for reading codec register */
1424 data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
1425 ATI_REG_PHYS_OUT_ADDR_EN |
1426 ATI_REG_PHYS_OUT_RW |
1427 co->codec_nr;
1428
1429 bus_space_write_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR, data);
1430
1431 if (auixp_wait_for_codecs(sc, "read_codec"))
1432 return 0xffff;
1433
1434 /* wait until codec info is clocked in */
1435 timeout = 500; /* 500*2 usec -> 0.001 sec */
1436 do {
1437 data = bus_space_read_4(iot, ioh, ATI_REG_PHYS_IN_ADDR);
1438 if (data & ATI_REG_PHYS_IN_READ_FLAG) {
1439 DPRINTF(("read ac'97 codec reg 0x%x = 0x%08x\n",
1440 reg, data >> ATI_REG_PHYS_IN_DATA_SHIFT)
1441 );
1442 *result = data >> ATI_REG_PHYS_IN_DATA_SHIFT;
1443 return 0;
1444 }
1445 DELAY(2);
1446 timeout--;
1447 } while (timeout > 0);
1448
1449 if (reg < 0x7c)
1450 printf("%s: codec read timeout! (reg %x)\n",
1451 device_xname(sc->sc_dev), reg);
1452
1453 return 0xffff;
1454 }
1455
1456
1457 static int
1458 auixp_write_codec(void *aux, uint8_t reg, uint16_t data)
1459 {
1460 struct auixp_codec *co;
1461 struct auixp_softc *sc;
1462 bus_space_tag_t iot;
1463 bus_space_handle_t ioh;
1464 uint32_t value;
1465
1466 DPRINTF(("write ac'97 codec reg 0x%x = 0x%08x\n", reg, data));
1467 co = aux;
1468 sc = co->sc;
1469 iot = sc->sc_iot;
1470 ioh = sc->sc_ioh;
1471 if (auixp_wait_for_codecs(sc, "write_codec"))
1472 return -1;
1473
1474 /* build up command for writing codec register */
1475 value = (((uint32_t) data) << ATI_REG_PHYS_OUT_DATA_SHIFT) |
1476 (((uint32_t) reg) << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
1477 ATI_REG_PHYS_OUT_ADDR_EN |
1478 co->codec_nr;
1479
1480 bus_space_write_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR, value);
1481
1482 return 0;
1483 }
1484
1485
1486 static int
1487 auixp_reset_codec(void *aux)
1488 {
1489
1490 /* nothing to be done? */
1491 return 0;
1492 }
1493
1494
1495 static enum ac97_host_flags
1496 auixp_flags_codec(void *aux)
1497 {
1498 struct auixp_codec *ixp_codec;
1499
1500 ixp_codec = aux;
1501 return ixp_codec->codec_flags;
1502 }
1503
1504
1505 static int
1506 auixp_wait_for_codecs(struct auixp_softc *sc, const char *func)
1507 {
1508 bus_space_tag_t iot;
1509 bus_space_handle_t ioh;
1510 uint32_t value;
1511 int timeout;
1512
1513 iot = sc->sc_iot;
1514 ioh = sc->sc_ioh;
1515 /* wait until all codec transfers are done */
1516 timeout = 500; /* 500*2 usec -> 0.001 sec */
1517 do {
1518 value = bus_space_read_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR);
1519 if ((value & ATI_REG_PHYS_OUT_ADDR_EN) == 0)
1520 return 0;
1521
1522 DELAY(2);
1523 timeout--;
1524 } while (timeout > 0);
1525
1526 printf("%s: %s: timed out\n", func, device_xname(sc->sc_dev));
1527 return -1;
1528 }
1529
1530
1531
1532 static void
1533 auixp_autodetect_codecs(struct auixp_softc *sc)
1534 {
1535 bus_space_tag_t iot;
1536 bus_space_handle_t ioh;
1537 struct auixp_codec *codec;
1538 int timeout, codec_nr;
1539
1540 iot = sc->sc_iot;
1541 ioh = sc->sc_ioh;
1542 /* ATI IXP can have upto 3 codecs; mark all codecs as not existing */
1543 sc->sc_codec_not_ready_bits = 0;
1544 sc->sc_num_codecs = 0;
1545
1546 /* enable all codecs to interrupt as well as the new frame interrupt */
1547 bus_space_write_4(iot, ioh, ATI_REG_IER, CODEC_CHECK_BITS);
1548
1549 /* wait for the interrupts to happen */
1550 timeout = 100; /* 100.000 usec -> 0.1 sec */
1551
1552 while (timeout > 0) {
1553 DELAY(1000);
1554 if (sc->sc_codec_not_ready_bits)
1555 break;
1556 timeout--;
1557 }
1558
1559 if (timeout == 0)
1560 printf("%s: WARNING: timeout during codec detection; "
1561 "codecs might be present but haven't interrupted\n",
1562 device_xname(sc->sc_dev));
1563
1564 /* disable all interrupts for now */
1565 auixp_disable_interrupts(sc);
1566
1567 /* Attach AC97 host interfaces */
1568 for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) {
1569 codec = &sc->sc_codec[codec_nr];
1570 memset(codec, 0, sizeof(struct auixp_codec));
1571
1572 codec->sc = sc;
1573 codec->codec_nr = codec_nr;
1574 codec->present = 0;
1575
1576 codec->host_if.arg = codec;
1577 codec->host_if.attach = auixp_attach_codec;
1578 codec->host_if.read = auixp_read_codec;
1579 codec->host_if.write = auixp_write_codec;
1580 codec->host_if.reset = auixp_reset_codec;
1581 codec->host_if.flags = auixp_flags_codec;
1582 }
1583
1584 if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC0_NOT_READY)) {
1585 /* codec 0 present */
1586 DPRINTF(("auixp : YAY! codec 0 present!\n"));
1587 if (ac97_attach(&sc->sc_codec[0].host_if, sc->sc_dev,
1588 &sc->sc_lock) == 0)
1589 sc->sc_num_codecs++;
1590 }
1591
1592 if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC1_NOT_READY)) {
1593 /* codec 1 present */
1594 DPRINTF(("auixp : YAY! codec 1 present!\n"));
1595 if (ac97_attach(&sc->sc_codec[1].host_if, sc->sc_dev,
1596 &sc->sc_lock) == 0)
1597 sc->sc_num_codecs++;
1598 }
1599
1600 if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC2_NOT_READY)) {
1601 /* codec 2 present */
1602 DPRINTF(("auixp : YAY! codec 2 present!\n"));
1603 if (ac97_attach(&sc->sc_codec[2].host_if, sc->sc_dev,
1604 &sc->sc_lock) == 0)
1605 sc->sc_num_codecs++;
1606 }
1607
1608 if (sc->sc_num_codecs == 0) {
1609 printf("%s: no codecs detected or "
1610 "no codecs managed to initialise\n",
1611 device_xname(sc->sc_dev));
1612 return;
1613 }
1614
1615 }
1616
1617
1618
1619 /* initialisation routines */
1620
1621 static void
1622 auixp_disable_dma(struct auixp_softc *sc, struct auixp_dma *dma)
1623 {
1624 bus_space_tag_t iot;
1625 bus_space_handle_t ioh;
1626 uint32_t value;
1627
1628 iot = sc->sc_iot;
1629 ioh = sc->sc_ioh;
1630 /* lets not stress the DMA engine more than nessisary */
1631 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1632 if (value & dma->dma_enable_bit) {
1633 value &= ~dma->dma_enable_bit;
1634 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1635 }
1636 }
1637
1638
1639 static void
1640 auixp_enable_dma(struct auixp_softc *sc, struct auixp_dma *dma)
1641 {
1642 bus_space_tag_t iot;
1643 bus_space_handle_t ioh;
1644 uint32_t value;
1645
1646 iot = sc->sc_iot;
1647 ioh = sc->sc_ioh;
1648 /* lets not stress the DMA engine more than nessisary */
1649 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1650 if (!(value & dma->dma_enable_bit)) {
1651 value |= dma->dma_enable_bit;
1652 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1653 }
1654 }
1655
1656
1657 static void
1658 auixp_reset_aclink(struct auixp_softc *sc)
1659 {
1660 bus_space_tag_t iot;
1661 bus_space_handle_t ioh;
1662 uint32_t value, timeout;
1663
1664 iot = sc->sc_iot;
1665 ioh = sc->sc_ioh;
1666
1667 /* if power is down, power it up */
1668 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1669 if (value & ATI_REG_CMD_POWERDOWN) {
1670 printf("%s: powering up\n", device_xname(sc->sc_dev));
1671
1672 /* explicitly enable power */
1673 value &= ~ATI_REG_CMD_POWERDOWN;
1674 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1675
1676 /* have to wait at least 10 usec for it to initialise */
1677 DELAY(20);
1678 };
1679
1680 printf("%s: soft resetting aclink\n", device_xname(sc->sc_dev));
1681
1682 /* perform a soft reset */
1683 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1684 value |= ATI_REG_CMD_AC_SOFT_RESET;
1685 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1686
1687 /* need to read the CMD reg and wait aprox. 10 usec to init */
1688 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1689 DELAY(20);
1690
1691 /* clear soft reset flag again */
1692 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1693 value &= ~ATI_REG_CMD_AC_SOFT_RESET;
1694 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1695
1696 /* check if the ac-link is working; reset device otherwise */
1697 timeout = 10;
1698 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1699 while (!(value & ATI_REG_CMD_ACLINK_ACTIVE)) {
1700 printf("%s: not up; resetting aclink hardware\n",
1701 device_xname(sc->sc_dev));
1702
1703 /* dip aclink reset but keep the acsync */
1704 value &= ~ATI_REG_CMD_AC_RESET;
1705 value |= ATI_REG_CMD_AC_SYNC;
1706 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1707
1708 /* need to read CMD again and wait again (clocking in issue?) */
1709 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1710 DELAY(20);
1711
1712 /* assert aclink reset again */
1713 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1714 value |= ATI_REG_CMD_AC_RESET;
1715 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1716
1717 /* check if its active now */
1718 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1719
1720 timeout--;
1721 if (timeout == 0) break;
1722 };
1723
1724 if (timeout == 0) {
1725 printf("%s: giving up aclink reset\n", device_xname(sc->sc_dev));
1726 };
1727 if (timeout != 10) {
1728 printf("%s: aclink hardware reset successful\n",
1729 device_xname(sc->sc_dev));
1730 };
1731
1732 /* assert reset and sync for safety */
1733 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1734 value |= ATI_REG_CMD_AC_SYNC | ATI_REG_CMD_AC_RESET;
1735 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1736 }
1737
1738
1739 /* chip hard init */
1740 static int
1741 auixp_init(struct auixp_softc *sc)
1742 {
1743 bus_space_tag_t iot;
1744 bus_space_handle_t ioh;
1745 uint32_t value;
1746
1747 iot = sc->sc_iot;
1748 ioh = sc->sc_ioh;
1749 /* disable all interrupts and clear all sources */
1750 auixp_disable_interrupts(sc);
1751
1752 /* clear all DMA enables (preserving rest of settings) */
1753 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1754 value &= ~( ATI_REG_CMD_IN_DMA_EN |
1755 ATI_REG_CMD_OUT_DMA_EN |
1756 ATI_REG_CMD_SPDF_OUT_EN );
1757 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1758
1759 /* Reset AC-link */
1760 auixp_reset_aclink(sc);
1761
1762 /*
1763 * codecs get auto-detected later
1764 *
1765 * note: we are NOT enabling interrupts yet, no codecs have been
1766 * detected yet nor is anything else set up
1767 */
1768
1769 return 0;
1770 }
1771
1772 static bool
1773 auixp_resume(device_t dv, const pmf_qual_t *qual)
1774 {
1775 struct auixp_softc *sc = device_private(dv);
1776
1777 mutex_enter(&sc->sc_lock);
1778 auixp_reset_codec(sc);
1779 delay(1000);
1780 (sc->sc_codec[0].codec_if->vtbl->restore_ports)(sc->sc_codec[0].codec_if);
1781 mutex_exit(&sc->sc_lock);
1782
1783 return true;
1784 }
1785
1786 #ifdef DEBUG_AUIXP
1787
1788 static void
1789 auixp_dumpreg(void)
1790 {
1791 struct auixp_softc *sc;
1792 bus_space_tag_t iot;
1793 bus_space_handle_t ioh;
1794 int i;
1795
1796 sc = static_sc;
1797 iot = sc->sc_iot;
1798 ioh = sc->sc_ioh;
1799 printf("%s register dump:\n", device_xname(sc->sc_dev));
1800 for (i = 0; i < 256; i+=4) {
1801 printf("\t0x%02x: 0x%08x\n", i, bus_space_read_4(iot, ioh, i));
1802 }
1803 printf("\n");
1804 }
1805 #endif
1806
1807 static void
1808 auixp_get_locks(void *addr, kmutex_t **intr, kmutex_t **proc)
1809 {
1810 struct auixp_codec *co = addr;
1811 struct auixp_softc *sc = co->sc;
1812
1813 *intr = &sc->sc_intr_lock;
1814 *proc = &sc->sc_lock;
1815 }
1816