auixp.c revision 1.37.2.1 1 /* $NetBSD: auixp.c,v 1.37.2.1 2012/02/18 07:34:35 mrg 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.37.2.1 2012/02/18 07:34:35 mrg 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(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 if (!dma)
474 return NULL;
475
476 /* get us a dma buffer itself */
477 error = auixp_allocmem(sc, size, 16, dma);
478 if (error) {
479 kmem_free(dma, sizeof(*dma));
480 aprint_error_dev(&sc->sc_dev, "auixp_malloc: not enough memory\n");
481
482 return NULL;
483 }
484 SLIST_INSERT_HEAD(&sc->sc_dma_list, dma, dma_chain);
485
486 DPRINTF(("auixp_malloc: returning kern %p, hw 0x%08x for %d bytes "
487 "in %d segs\n", KERNADDR(dma), (uint32_t) DMAADDR(dma), dma->size,
488 dma->nsegs)
489 );
490
491 return KERNADDR(dma);
492 }
493
494
495 /*
496 * free and release dma capable memory we allocated before and remove its
497 * recording
498 */
499 static void
500 auixp_free(void *hdl, void *addr, size_t size)
501 {
502 struct auixp_codec *co;
503 struct auixp_softc *sc;
504 struct auixp_dma *dma;
505
506 co = (struct auixp_codec *) hdl;
507 sc = co->sc;
508 SLIST_FOREACH(dma, &sc->sc_dma_list, dma_chain) {
509 if (KERNADDR(dma) == addr) {
510 SLIST_REMOVE(&sc->sc_dma_list, dma, auixp_dma,
511 dma_chain);
512 auixp_freemem(sc, dma);
513 kmem_free(dma, sizeof(*dma));
514 return;
515 }
516 }
517 }
518
519
520 static int
521 auixp_getdev(void *hdl, struct audio_device *ret)
522 {
523
524 *ret = auixp_device;
525 return 0;
526 }
527
528
529 /* pass request to AC'97 codec code */
530 static int
531 auixp_set_port(void *hdl, mixer_ctrl_t *mc)
532 {
533 struct auixp_codec *co;
534
535 co = (struct auixp_codec *) hdl;
536 return co->codec_if->vtbl->mixer_set_port(co->codec_if, mc);
537 }
538
539
540 /* pass request to AC'97 codec code */
541 static int
542 auixp_get_port(void *hdl, mixer_ctrl_t *mc)
543 {
544 struct auixp_codec *co;
545
546 co = (struct auixp_codec *) hdl;
547 return co->codec_if->vtbl->mixer_get_port(co->codec_if, mc);
548 }
549
550 /* pass request to AC'97 codec code */
551 static int
552 auixp_query_devinfo(void *hdl, mixer_devinfo_t *di)
553 {
554 struct auixp_codec *co;
555
556 co = (struct auixp_codec *) hdl;
557 return co->codec_if->vtbl->query_devinfo(co->codec_if, di);
558 }
559
560
561 static size_t
562 auixp_round_buffersize(void *hdl, int direction,
563 size_t bufsize)
564 {
565
566 /* XXX force maximum? i.e. 256 kb? */
567 return bufsize;
568 }
569
570
571 static int
572 auixp_get_props(void *hdl)
573 {
574
575 return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
576 }
577
578
579 /*
580 * A dma descriptor has dma->nsegs segments defined in dma->segs set up when
581 * we claimed the memory.
582 *
583 * Due to our demand for one contiguous DMA area, we only have one segment. A
584 * c_dma structure is about 3 kb for the 256 entries we maximally program
585 * -arbitrary limit AFAIK- so all is most likely to be in one segment/page
586 * anyway.
587 *
588 * XXX ought to implement fragmented dma area XXX
589 *
590 * Note that _v variables depict kernel virtual addresses, _p variables depict
591 * physical addresses.
592 */
593 static void
594 auixp_link_daisychain(struct auixp_softc *sc,
595 struct auixp_dma *c_dma, struct auixp_dma *s_dma,
596 int blksize, int blocks)
597 {
598 atiixp_dma_desc_t *caddr_v, *next_caddr_v;
599 uint32_t caddr_p, next_caddr_p, saddr_p;
600 int i;
601
602 /* just make sure we are not changing when its running */
603 auixp_disable_dma(sc, c_dma);
604
605 /* setup dma chain start addresses */
606 caddr_v = KERNADDR(c_dma);
607 caddr_p = DMAADDR(c_dma);
608 saddr_p = DMAADDR(s_dma);
609
610 /* program the requested number of blocks */
611 for (i = 0; i < blocks; i++) {
612 /* clear the block just in case */
613 memset(caddr_v, 0, sizeof(atiixp_dma_desc_t));
614
615 /* round robin the chain dma addresses for its successor */
616 next_caddr_v = caddr_v + 1;
617 next_caddr_p = caddr_p + sizeof(atiixp_dma_desc_t);
618
619 if (i == blocks-1) {
620 next_caddr_v = KERNADDR(c_dma);
621 next_caddr_p = DMAADDR(c_dma);
622 }
623
624 /* fill in the hardware dma chain descriptor in little-endian */
625 caddr_v->addr = htole32(saddr_p);
626 caddr_v->status = htole16(0);
627 caddr_v->size = htole16((blksize >> 2)); /* in dwords (!!!) */
628 caddr_v->next = htole32(next_caddr_p);
629
630 /* advance slot */
631 saddr_p += blksize; /* XXX assuming contiguous XXX */
632 caddr_v = next_caddr_v;
633 caddr_p = next_caddr_p;
634 }
635 }
636
637
638 static int
639 auixp_allocate_dma_chain(struct auixp_softc *sc, struct auixp_dma **dmap)
640 {
641 struct auixp_dma *dma;
642 int error;
643
644 /* allocate keeper of dma area */
645 *dmap = NULL;
646 dma = kmem_zalloc(sizeof(struct auixp_dma), KM_SLEEP);
647 if (!dma)
648 return ENOMEM;
649
650 /* allocate for daisychain of IXP hardware-dma descriptors */
651 error = auixp_allocmem(sc, DMA_DESC_CHAIN * sizeof(atiixp_dma_desc_t),
652 16, dma);
653 if (error) {
654 aprint_error_dev(&sc->sc_dev, "can't malloc dma descriptor chain\n");
655 kmem_free(dma, sizeof(*dma));
656 return ENOMEM;
657 }
658
659 /* return info and initialise structure */
660 dma->intr = NULL;
661 dma->intrarg = NULL;
662
663 *dmap = dma;
664 return 0;
665 }
666
667
668 /* program dma chain in it's link address descriptor */
669 static void
670 auixp_program_dma_chain(struct auixp_softc *sc, struct auixp_dma *dma)
671 {
672 bus_space_tag_t iot;
673 bus_space_handle_t ioh;
674 uint32_t value;
675
676 iot = sc->sc_iot;
677 ioh = sc->sc_ioh;
678 /* get hardware start address of DMA chain and set valid-flag in it */
679 /* XXX always at start? XXX */
680 value = DMAADDR(dma);
681 value = value | ATI_REG_LINKPTR_EN;
682
683 /* reset linkpointer */
684 bus_space_write_4(iot, ioh, dma->linkptr, 0);
685
686 /* reset this DMA engine */
687 auixp_disable_dma(sc, dma);
688 auixp_enable_dma(sc, dma);
689
690 /* program new DMA linkpointer */
691 bus_space_write_4(iot, ioh, dma->linkptr, value);
692 }
693
694
695 /* called from interrupt code to signal end of one dma-slot */
696 static void
697 auixp_dma_update(struct auixp_softc *sc, struct auixp_dma *dma)
698 {
699
700 /* be very paranoid */
701 if (!dma)
702 panic("%s: update: dma = NULL", device_xname(&sc->sc_dev));
703 if (!dma->intr)
704 panic("%s: update: dma->intr = NULL", device_xname(&sc->sc_dev));
705
706 /* request more input from upper layer */
707 (*dma->intr)(dma->intrarg);
708 }
709
710
711 /*
712 * The magic `busbusy' bit that needs to be set when dma is active; allowing
713 * busmastering?
714 */
715 static void
716 auixp_update_busbusy(struct auixp_softc *sc)
717 {
718 bus_space_tag_t iot;
719 bus_space_handle_t ioh;
720 uint32_t value;
721 int running;
722
723 iot = sc->sc_iot;
724 ioh = sc->sc_ioh;
725 /* set bus-busy flag when either recording or playing is performed */
726 value = bus_space_read_4(iot, ioh, ATI_REG_IER);
727 value &= ~ATI_REG_IER_SET_BUS_BUSY;
728
729 running = ((sc->sc_output_dma->running) || (sc->sc_input_dma->running));
730 if (running)
731 value |= ATI_REG_IER_SET_BUS_BUSY;
732
733 bus_space_write_4(iot, ioh, ATI_REG_IER, value);
734
735 }
736
737
738 /*
739 * Called from upper audio layer to request playing audio, only called once;
740 * audio is refilled by calling the intr() function when space is available
741 * again.
742 */
743 /* XXX allmost literaly a copy of trigger-input; could be factorised XXX */
744 static int
745 auixp_trigger_output(void *hdl, void *start, void *end, int blksize,
746 void (*intr)(void *), void *intrarg, const audio_params_t *param)
747 {
748 struct auixp_codec *co;
749 struct auixp_softc *sc;
750 struct auixp_dma *chain_dma;
751 struct auixp_dma *sound_dma;
752 uint32_t blocks;
753
754 co = (struct auixp_codec *) hdl;
755 sc = co->sc;
756 chain_dma = sc->sc_output_dma;
757 /* add functions to call back */
758 chain_dma->intr = intr;
759 chain_dma->intrarg = intrarg;
760
761 /*
762 * Program output DMA chain with blocks from [start...end] with
763 * blksize fragments.
764 *
765 * NOTE, we can assume its in one block since we asked for it to be in
766 * one contiguous blob; XXX change this? XXX
767 */
768 blocks = (size_t) (((char *) end) - ((char *) start)) / blksize;
769
770 /* lookup `start' address in our list of DMA area's */
771 SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) {
772 if (KERNADDR(sound_dma) == start)
773 break;
774 }
775
776 /* not ours ? then bail out */
777 if (!sound_dma) {
778 printf("%s: auixp_trigger_output: bad sound addr %p\n",
779 device_xname(&sc->sc_dev), start);
780 return EINVAL;
781 }
782
783 /* link round-robin daisychain and program hardware */
784 auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks);
785 auixp_program_dma_chain(sc, chain_dma);
786
787 /* mark we are now able to run now */
788 chain_dma->running = 1;
789
790 /* update bus-flags; XXX programs more flags XXX */
791 auixp_update_busbusy(sc);
792
793 /* callbacks happen in interrupt routine */
794 return 0;
795 }
796
797
798 /* halt output of audio, just disable it's dma and update bus state */
799 static int
800 auixp_halt_output(void *hdl)
801 {
802 struct auixp_codec *co;
803 struct auixp_softc *sc;
804 struct auixp_dma *dma;
805
806 co = (struct auixp_codec *) hdl;
807 sc = co->sc;
808 dma = sc->sc_output_dma;
809 auixp_disable_dma(sc, dma);
810
811 dma->running = 0;
812 auixp_update_busbusy(sc);
813
814 return 0;
815 }
816
817
818 /* XXX allmost literaly a copy of trigger-output; could be factorised XXX */
819 static int
820 auixp_trigger_input(void *hdl, void *start, void *end, int blksize,
821 void (*intr)(void *), void *intrarg, const audio_params_t *param)
822 {
823 struct auixp_codec *co;
824 struct auixp_softc *sc;
825 struct auixp_dma *chain_dma;
826 struct auixp_dma *sound_dma;
827 uint32_t blocks;
828
829 co = (struct auixp_codec *) hdl;
830 sc = co->sc;
831 chain_dma = sc->sc_input_dma;
832 /* add functions to call back */
833 chain_dma->intr = intr;
834 chain_dma->intrarg = intrarg;
835
836 /*
837 * Program output DMA chain with blocks from [start...end] with
838 * blksize fragments.
839 *
840 * NOTE, we can assume its in one block since we asked for it to be in
841 * one contiguous blob; XXX change this? XXX
842 */
843 blocks = (size_t) (((char *) end) - ((char *) start)) / blksize;
844
845 /* lookup `start' address in our list of DMA area's */
846 SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) {
847 if (KERNADDR(sound_dma) == start)
848 break;
849 }
850
851 /* not ours ? then bail out */
852 if (!sound_dma) {
853 printf("%s: auixp_trigger_input: bad sound addr %p\n",
854 device_xname(&sc->sc_dev), start);
855 return EINVAL;
856 }
857
858 /* link round-robin daisychain and program hardware */
859 auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks);
860 auixp_program_dma_chain(sc, chain_dma);
861
862 /* mark we are now able to run now */
863 chain_dma->running = 1;
864
865 /* update bus-flags; XXX programs more flags XXX */
866 auixp_update_busbusy(sc);
867
868 /* callbacks happen in interrupt routine */
869 return 0;
870 }
871
872
873 /* halt sampling audio, just disable it's dma and update bus state */
874 static int
875 auixp_halt_input(void *hdl)
876 {
877 struct auixp_codec *co;
878 struct auixp_softc *sc;
879 struct auixp_dma *dma;
880
881 co = (struct auixp_codec *) hdl;
882 sc = co->sc;
883 dma = sc->sc_input_dma;
884 auixp_disable_dma(sc, dma);
885
886 dma->running = 0;
887 auixp_update_busbusy(sc);
888
889 return 0;
890 }
891
892
893 /*
894 * IXP audio interrupt handler
895 *
896 * note that we return the number of bits handled; the return value is not
897 * documentated but i saw it implemented in other drivers. Prolly returning a
898 * value > 0 means "i've dealt with it"
899 *
900 */
901 static int
902 auixp_intr(void *softc)
903 {
904 struct auixp_softc *sc;
905 bus_space_tag_t iot;
906 bus_space_handle_t ioh;
907 uint32_t status, enable, detected_codecs;
908 int ret;
909
910 sc = softc;
911 mutex_spin_enter(&sc->sc_intr_lock);
912
913 iot = sc->sc_iot;
914 ioh = sc->sc_ioh;
915 ret = 0;
916 /* get status from the interrupt status register */
917 status = bus_space_read_4(iot, ioh, ATI_REG_ISR);
918
919 if (status == 0) {
920 mutex_spin_exit(&sc->sc_intr_lock);
921 return 0;
922 }
923
924 DPRINTF(("%s: (status = %x)\n", device_xname(&sc->sc_dev), status));
925
926 /* check DMA UPDATE flags for input & output */
927 if (status & ATI_REG_ISR_IN_STATUS) {
928 ret++; DPRINTF(("IN_STATUS\n"));
929 auixp_dma_update(sc, sc->sc_input_dma);
930 }
931 if (status & ATI_REG_ISR_OUT_STATUS) {
932 ret++; DPRINTF(("OUT_STATUS\n"));
933 auixp_dma_update(sc, sc->sc_output_dma);
934 }
935
936 /* XXX XRUN flags not used/needed yet; should i implement it? XXX */
937 /* acknowledge the interrupts nevertheless */
938 if (status & ATI_REG_ISR_IN_XRUN) {
939 ret++; DPRINTF(("IN_XRUN\n"));
940 /* auixp_dma_xrun(sc, sc->sc_input_dma); */
941 }
942 if (status & ATI_REG_ISR_OUT_XRUN) {
943 ret++; DPRINTF(("OUT_XRUN\n"));
944 /* auixp_dma_xrun(sc, sc->sc_output_dma); */
945 }
946
947 /* check if we are looking for codec detection */
948 if (status & CODEC_CHECK_BITS) {
949 ret++;
950 /* mark missing codecs as not ready */
951 detected_codecs = status & CODEC_CHECK_BITS;
952 sc->sc_codec_not_ready_bits |= detected_codecs;
953
954 /* disable detected interrupt sources */
955 enable = bus_space_read_4(iot, ioh, ATI_REG_IER);
956 enable &= ~detected_codecs;
957 bus_space_write_4(iot, ioh, ATI_REG_IER, enable);
958 }
959
960 /* acknowledge interrupt sources */
961 bus_space_write_4(iot, ioh, ATI_REG_ISR, status);
962
963 mutex_spin_exit(&sc->sc_intr_lock);
964 return ret;
965 }
966
967
968 /* allocate memory for dma purposes; on failure of any of the steps, roll back */
969 static int
970 auixp_allocmem(struct auixp_softc *sc, size_t size,
971 size_t align, struct auixp_dma *dma)
972 {
973 int error;
974
975 /* remember size */
976 dma->size = size;
977
978 /* allocate DMA safe memory but in just one segment for now :( */
979 error = bus_dmamem_alloc(sc->sc_dmat, dma->size, align, 0,
980 dma->segs, sizeof(dma->segs) / sizeof(dma->segs[0]), &dma->nsegs,
981 BUS_DMA_WAITOK);
982 if (error)
983 return error;
984
985 /*
986 * map allocated memory into kernel virtual address space and keep it
987 * coherent with the CPU.
988 */
989 error = bus_dmamem_map(sc->sc_dmat, dma->segs, dma->nsegs, dma->size,
990 &dma->addr, BUS_DMA_WAITOK | BUS_DMA_COHERENT);
991 if (error)
992 goto free;
993
994 /* allocate associated dma handle and initialize it. */
995 error = bus_dmamap_create(sc->sc_dmat, dma->size, 1, dma->size, 0,
996 BUS_DMA_WAITOK, &dma->map);
997 if (error)
998 goto unmap;
999
1000 /*
1001 * load the dma handle with mappings for a dma transfer; all pages
1002 * need to be wired.
1003 */
1004 error = bus_dmamap_load(sc->sc_dmat, dma->map, dma->addr, dma->size, NULL,
1005 BUS_DMA_WAITOK);
1006 if (error)
1007 goto destroy;
1008
1009 return 0;
1010
1011 destroy:
1012 bus_dmamap_destroy(sc->sc_dmat, dma->map);
1013 unmap:
1014 bus_dmamem_unmap(sc->sc_dmat, dma->addr, dma->size);
1015 free:
1016 bus_dmamem_free(sc->sc_dmat, dma->segs, dma->nsegs);
1017
1018 return error;
1019 }
1020
1021
1022 /* undo dma mapping and release memory allocated */
1023 static int
1024 auixp_freemem(struct auixp_softc *sc, struct auixp_dma *p)
1025 {
1026
1027 bus_dmamap_unload(sc->sc_dmat, p->map);
1028 bus_dmamap_destroy(sc->sc_dmat, p->map);
1029 bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
1030 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
1031
1032 return 0;
1033 }
1034
1035
1036 /* memory map dma memory */
1037 static paddr_t
1038 auixp_mappage(void *hdl, void *mem, off_t off, int prot)
1039 {
1040 struct auixp_codec *co;
1041 struct auixp_softc *sc;
1042 struct auixp_dma *p;
1043
1044 co = (struct auixp_codec *) hdl;
1045 sc = co->sc;
1046 /* for sanity */
1047 if (off < 0)
1048 return -1;
1049
1050 /* look up allocated DMA area */
1051 SLIST_FOREACH(p, &sc->sc_dma_list, dma_chain) {
1052 if (KERNADDR(p) == mem)
1053 break;
1054 }
1055
1056 /* have we found it ? */
1057 if (!p)
1058 return -1;
1059
1060 /* return mmap'd region */
1061 return bus_dmamem_mmap(sc->sc_dmat, p->segs, p->nsegs,
1062 off, prot, BUS_DMA_WAITOK);
1063 }
1064
1065
1066 /*
1067 * Attachment section
1068 */
1069
1070 /* Is it my hardware? */
1071 static int
1072 auixp_match(device_t dev, cfdata_t match, void *aux)
1073 {
1074 struct pci_attach_args *pa;
1075
1076 pa = (struct pci_attach_args *)aux;
1077 switch(PCI_VENDOR(pa->pa_id)) {
1078 case PCI_VENDOR_ATI:
1079 switch(PCI_PRODUCT(pa->pa_id)) {
1080 case PCI_PRODUCT_ATI_IXP_AUDIO_200:
1081 case PCI_PRODUCT_ATI_IXP_AUDIO_300:
1082 case PCI_PRODUCT_ATI_IXP_AUDIO_400:
1083 return 1;
1084 }
1085 }
1086
1087 return 0;
1088 }
1089
1090
1091 /* it is... now hook up and set up the resources we need */
1092 static void
1093 auixp_attach(device_t parent, device_t self, void *aux)
1094 {
1095 struct auixp_softc *sc;
1096 struct pci_attach_args *pa;
1097 pcitag_t tag;
1098 pci_chipset_tag_t pc;
1099 pci_intr_handle_t ih;
1100 const struct auixp_card_type *card;
1101 const char *intrstr;
1102 uint32_t data;
1103 int error;
1104
1105 sc = device_private(self);
1106 pa = (struct pci_attach_args *)aux;
1107 tag = pa->pa_tag;
1108 pc = pa->pa_pc;
1109 #ifdef DEBUG_AUIXP
1110 static_sc = sc;
1111 #endif
1112
1113 /* print information confirming attachment */
1114 pci_aprint_devinfo(pa, "Audio controller");
1115
1116 /* set up details from our set of known `cards'/chips */
1117 for (card = auixp_card_types; card->pci_vendor_id; card++)
1118 if (PCI_VENDOR(pa->pa_id) == card->pci_vendor_id &&
1119 PCI_PRODUCT(pa->pa_id) == card->pci_product_id) {
1120 sc->type = card->type;
1121 break;
1122 }
1123
1124 /* device only has 32 bit non prefetchable memory */
1125 /* set MEM space access and enable the card's busmastering */
1126 data = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
1127 data |= (PCI_COMMAND_MEM_ENABLE | PCI_COMMAND_MASTER_ENABLE);
1128 pci_conf_write(pc, tag, PCI_COMMAND_STATUS_REG, data);
1129
1130 /* map memory; its not sized -> what is the size? max PCI slot size? */
1131 if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_MEM, 0,
1132 &sc->sc_iot, &sc->sc_ioh, &sc->sc_iob, &sc->sc_ios)) {
1133 aprint_error_dev(&sc->sc_dev, "can't map memory space\n");
1134 return;
1135 }
1136
1137 /* Initialize softc */
1138 sc->sc_tag = tag;
1139 sc->sc_pct = pc;
1140 sc->sc_dmat = pa->pa_dmat;
1141 SLIST_INIT(&sc->sc_dma_list);
1142
1143 /* get us the auixp_dma structures */
1144 auixp_allocate_dma_chain(sc, &sc->sc_output_dma);
1145 auixp_allocate_dma_chain(sc, &sc->sc_input_dma);
1146
1147 /* when that fails we are dead in the water */
1148 if (!sc->sc_output_dma || !sc->sc_input_dma)
1149 return;
1150
1151 #if 0
1152 /* could preliminary program DMA chain */
1153 auixp_program_dma_chain(sc, sc->sc_output_dma);
1154 auixp_program_dma_chain(sc, sc->sc_input_dma);
1155 #endif
1156
1157 /* map interrupt on the pci bus */
1158 if (pci_intr_map(pa, &ih)) {
1159 aprint_error_dev(&sc->sc_dev, "can't map interrupt\n");
1160 return;
1161 }
1162
1163 /* where are we connected at ? */
1164 intrstr = pci_intr_string(pc, ih);
1165
1166 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
1167 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_AUDIO);
1168
1169 /* establish interrupt routine hookup at IPL_AUDIO level */
1170 sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, auixp_intr, self);
1171 if (sc->sc_ih == NULL) {
1172 aprint_error_dev(&sc->sc_dev, "can't establish interrupt");
1173 if (intrstr != NULL)
1174 aprint_error(" at %s", intrstr);
1175 aprint_error("\n");
1176 return;
1177 }
1178 aprint_normal_dev(&sc->sc_dev, "interrupting at %s\n", intrstr);
1179
1180 /* power up chip */
1181 if ((error = pci_activate(pa->pa_pc, pa->pa_tag, self,
1182 pci_activate_null)) && error != EOPNOTSUPP) {
1183 aprint_error_dev(&sc->sc_dev, "cannot activate %d\n",
1184 error);
1185 return;
1186 }
1187
1188 /* init chip */
1189 if (auixp_init(sc) == -1) {
1190 aprint_error_dev(&sc->sc_dev, "auixp_attach: unable to initialize the card\n");
1191 return;
1192 }
1193
1194 if (!pmf_device_register(self, NULL, auixp_resume))
1195 aprint_error_dev(self, "couldn't establish power handler\n");
1196
1197 /*
1198 * delay further configuration of codecs and audio after interrupts
1199 * are enabled.
1200 */
1201 config_interrupts(self, auixp_post_config);
1202 }
1203
1204
1205 /* called from autoconfigure system when interrupts are enabled */
1206 static void
1207 auixp_post_config(device_t self)
1208 {
1209 struct auixp_softc *sc;
1210 struct auixp_codec *codec;
1211 int codec_nr;
1212 int res, i;
1213
1214 sc = device_private(self);
1215 /* detect the AC97 codecs */
1216 auixp_autodetect_codecs(sc);
1217
1218 /* setup audio translation formats : following codec0 (!) */
1219 codec = &sc->sc_codec[0];
1220 if (!codec->present) {
1221 /* nothing??? then invalidate all formats */
1222 for (i = 0; i < AUIXP_NFORMATS; i++) {
1223 AUFMT_INVALIDATE(&sc->sc_formats[i]);
1224 }
1225 return;
1226 }
1227
1228 /* copy formats and invalidate entries not suitable for codec0 */
1229 memcpy(sc->sc_formats, auixp_formats, sizeof(auixp_formats));
1230 mutex_enter(&sc->sc_lock);
1231 sc->has_4ch = AC97_IS_4CH(codec->codec_if);
1232 sc->has_6ch = AC97_IS_6CH(codec->codec_if);
1233 sc->is_fixed = AC97_IS_FIXED_RATE(codec->codec_if);
1234 sc->has_spdif = AC97_HAS_SPDIF(codec->codec_if);
1235 mutex_exit(&sc->sc_lock);
1236
1237 for (i = 0; i < AUIXP_NFORMATS; i++) {
1238 if (sc->is_fixed) {
1239 sc->sc_formats[i].frequency_type = 1;
1240 sc->sc_formats[i].frequency[0] = 48000;
1241 }
1242 switch (sc->sc_formats[i].channels) {
1243 case 4 :
1244 if (sc->has_4ch)
1245 break;
1246 AUFMT_INVALIDATE(&sc->sc_formats[i]);
1247 break;
1248 case 6 :
1249 if (sc->has_6ch)
1250 break;
1251 AUFMT_INVALIDATE(&sc->sc_formats[i]);
1252 break;
1253 default :
1254 break;
1255 }
1256 }
1257
1258 /*
1259 * Create all encodings (and/or -translations) based on the formats
1260 * supported. */
1261 res = auconv_create_encodings(sc->sc_formats, AUIXP_NFORMATS,
1262 &sc->sc_encodings);
1263 if (res) {
1264 printf("%s: auconv_create_encodings failed; "
1265 "no attachments\n", device_xname(&sc->sc_dev));
1266 return;
1267 }
1268
1269 if (sc->has_spdif) {
1270 aprint_normal_dev(&sc->sc_dev, "codec spdif support detected but disabled "
1271 "for now\n");
1272 sc->has_spdif = 0;
1273 }
1274
1275 /* fill in the missing details about the dma channels. */
1276 /* for output */
1277 sc->sc_output_dma->linkptr = ATI_REG_OUT_DMA_LINKPTR;
1278 sc->sc_output_dma->dma_enable_bit = ATI_REG_CMD_OUT_DMA_EN |
1279 ATI_REG_CMD_SEND_EN;
1280 /* have spdif? then this too! XXX not seeing LED yet! XXX */
1281 if (sc->has_spdif)
1282 sc->sc_output_dma->dma_enable_bit |= ATI_REG_CMD_SPDF_OUT_EN;
1283
1284 /* and for input */
1285 sc->sc_input_dma->linkptr = ATI_REG_IN_DMA_LINKPTR;
1286 sc->sc_input_dma->dma_enable_bit = ATI_REG_CMD_IN_DMA_EN |
1287 ATI_REG_CMD_RECEIVE_EN;
1288
1289 /* attach audio devices for all detected codecs */
1290 /* XXX wise? look at other multiple-codec able chipsets XXX */
1291 for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) {
1292 codec = &sc->sc_codec[codec_nr];
1293 if (codec->present)
1294 audio_attach_mi(&auixp_hw_if, codec, &sc->sc_dev);
1295 }
1296
1297 /* done! now enable all interrupts we can service */
1298 auixp_enable_interrupts(sc);
1299 }
1300
1301 static void
1302 auixp_enable_interrupts(struct auixp_softc *sc)
1303 {
1304 bus_space_tag_t iot;
1305 bus_space_handle_t ioh;
1306 uint32_t value;
1307
1308 iot = sc->sc_iot;
1309 ioh = sc->sc_ioh;
1310
1311 mutex_spin_enter(&sc->sc_intr_lock);
1312
1313 /* clear all pending */
1314 bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff);
1315
1316 /* enable all relevant interrupt sources we can handle */
1317 value = bus_space_read_4(iot, ioh, ATI_REG_IER);
1318
1319 value |= ATI_REG_IER_IO_STATUS_EN;
1320 #ifdef notyet
1321 value |= ATI_REG_IER_IN_XRUN_EN;
1322 value |= ATI_REG_IER_OUT_XRUN_EN;
1323
1324 value |= ATI_REG_IER_SPDIF_XRUN_EN;
1325 value |= ATI_REG_IER_SPDF_STATUS_EN;
1326 #endif
1327
1328 bus_space_write_4(iot, ioh, ATI_REG_IER, value);
1329
1330 mutex_spin_exit(&sc->sc_intr_lock);
1331 }
1332
1333
1334 static void
1335 auixp_disable_interrupts(struct auixp_softc *sc)
1336 {
1337 bus_space_tag_t iot;
1338 bus_space_handle_t ioh;
1339
1340 iot = sc->sc_iot;
1341 ioh = sc->sc_ioh;
1342
1343 mutex_spin_enter(&sc->sc_intr_lock);
1344
1345 /* disable all interrupt sources */
1346 bus_space_write_4(iot, ioh, ATI_REG_IER, 0);
1347
1348 /* clear all pending */
1349 bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff);
1350
1351 mutex_spin_exit(&sc->sc_intr_lock);
1352 }
1353
1354
1355 /* dismantle what we've set up by undoing setup */
1356 static int
1357 auixp_detach(device_t self, int flags)
1358 {
1359 struct auixp_softc *sc;
1360
1361 sc = device_private(self);
1362 /* XXX shouldn't we just reset the chip? XXX */
1363 /*
1364 * should we explicitly disable interrupt generation and acknowledge
1365 * what's left on? better be safe than sorry.
1366 */
1367 auixp_disable_interrupts(sc);
1368
1369 /* tear down .... */
1370 config_detach(&sc->sc_dev, flags); /* XXX OK? XXX */
1371 pmf_device_deregister(self);
1372
1373 if (sc->sc_ih != NULL)
1374 pci_intr_disestablish(sc->sc_pct, sc->sc_ih);
1375 if (sc->sc_ios)
1376 bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
1377
1378 mutex_destroy(&sc->sc_lock);
1379 mutex_destroy(&sc->sc_intr_lock);
1380
1381 return 0;
1382 }
1383
1384
1385 /*
1386 * codec handling
1387 *
1388 * IXP audio support can have upto 3 codecs! are they chained ? or
1389 * alternative outlets with the same audio feed i.e. with different mixer
1390 * settings? XXX does NetBSD support more than one audio codec? XXX
1391 */
1392
1393
1394 static int
1395 auixp_attach_codec(void *aux, struct ac97_codec_if *codec_if)
1396 {
1397 struct auixp_codec *ixp_codec;
1398
1399 ixp_codec = aux;
1400 ixp_codec->codec_if = codec_if;
1401 ixp_codec->present = 1;
1402
1403 return 0;
1404 }
1405
1406
1407 static int
1408 auixp_read_codec(void *aux, uint8_t reg, uint16_t *result)
1409 {
1410 struct auixp_codec *co;
1411 struct auixp_softc *sc;
1412 bus_space_tag_t iot;
1413 bus_space_handle_t ioh;
1414 uint32_t data;
1415 int timeout;
1416
1417 co = aux;
1418 sc = co->sc;
1419 iot = sc->sc_iot;
1420 ioh = sc->sc_ioh;
1421 if (auixp_wait_for_codecs(sc, "read_codec"))
1422 return 0xffff;
1423
1424 /* build up command for reading codec register */
1425 data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
1426 ATI_REG_PHYS_OUT_ADDR_EN |
1427 ATI_REG_PHYS_OUT_RW |
1428 co->codec_nr;
1429
1430 bus_space_write_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR, data);
1431
1432 if (auixp_wait_for_codecs(sc, "read_codec"))
1433 return 0xffff;
1434
1435 /* wait until codec info is clocked in */
1436 timeout = 500; /* 500*2 usec -> 0.001 sec */
1437 do {
1438 data = bus_space_read_4(iot, ioh, ATI_REG_PHYS_IN_ADDR);
1439 if (data & ATI_REG_PHYS_IN_READ_FLAG) {
1440 DPRINTF(("read ac'97 codec reg 0x%x = 0x%08x\n",
1441 reg, data >> ATI_REG_PHYS_IN_DATA_SHIFT)
1442 );
1443 *result = data >> ATI_REG_PHYS_IN_DATA_SHIFT;
1444 return 0;
1445 }
1446 DELAY(2);
1447 timeout--;
1448 } while (timeout > 0);
1449
1450 if (reg < 0x7c)
1451 printf("%s: codec read timeout! (reg %x)\n",
1452 device_xname(&sc->sc_dev), reg);
1453
1454 return 0xffff;
1455 }
1456
1457
1458 static int
1459 auixp_write_codec(void *aux, uint8_t reg, uint16_t data)
1460 {
1461 struct auixp_codec *co;
1462 struct auixp_softc *sc;
1463 bus_space_tag_t iot;
1464 bus_space_handle_t ioh;
1465 uint32_t value;
1466
1467 DPRINTF(("write ac'97 codec reg 0x%x = 0x%08x\n", reg, data));
1468 co = aux;
1469 sc = co->sc;
1470 iot = sc->sc_iot;
1471 ioh = sc->sc_ioh;
1472 if (auixp_wait_for_codecs(sc, "write_codec"))
1473 return -1;
1474
1475 /* build up command for writing codec register */
1476 value = (((uint32_t) data) << ATI_REG_PHYS_OUT_DATA_SHIFT) |
1477 (((uint32_t) reg) << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
1478 ATI_REG_PHYS_OUT_ADDR_EN |
1479 co->codec_nr;
1480
1481 bus_space_write_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR, value);
1482
1483 return 0;
1484 }
1485
1486
1487 static int
1488 auixp_reset_codec(void *aux)
1489 {
1490
1491 /* nothing to be done? */
1492 return 0;
1493 }
1494
1495
1496 static enum ac97_host_flags
1497 auixp_flags_codec(void *aux)
1498 {
1499 struct auixp_codec *ixp_codec;
1500
1501 ixp_codec = aux;
1502 return ixp_codec->codec_flags;
1503 }
1504
1505
1506 static int
1507 auixp_wait_for_codecs(struct auixp_softc *sc, const char *func)
1508 {
1509 bus_space_tag_t iot;
1510 bus_space_handle_t ioh;
1511 uint32_t value;
1512 int timeout;
1513
1514 iot = sc->sc_iot;
1515 ioh = sc->sc_ioh;
1516 /* wait until all codec transfers are done */
1517 timeout = 500; /* 500*2 usec -> 0.001 sec */
1518 do {
1519 value = bus_space_read_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR);
1520 if ((value & ATI_REG_PHYS_OUT_ADDR_EN) == 0)
1521 return 0;
1522
1523 DELAY(2);
1524 timeout--;
1525 } while (timeout > 0);
1526
1527 printf("%s: %s: timed out\n", func, device_xname(&sc->sc_dev));
1528 return -1;
1529 }
1530
1531
1532
1533 static void
1534 auixp_autodetect_codecs(struct auixp_softc *sc)
1535 {
1536 bus_space_tag_t iot;
1537 bus_space_handle_t ioh;
1538 struct auixp_codec *codec;
1539 int timeout, codec_nr;
1540
1541 iot = sc->sc_iot;
1542 ioh = sc->sc_ioh;
1543 /* ATI IXP can have upto 3 codecs; mark all codecs as not existing */
1544 sc->sc_codec_not_ready_bits = 0;
1545 sc->sc_num_codecs = 0;
1546
1547 /* enable all codecs to interrupt as well as the new frame interrupt */
1548 bus_space_write_4(iot, ioh, ATI_REG_IER, CODEC_CHECK_BITS);
1549
1550 /* wait for the interrupts to happen */
1551 timeout = 100; /* 100.000 usec -> 0.1 sec */
1552
1553 while (timeout > 0) {
1554 DELAY(1000);
1555 if (sc->sc_codec_not_ready_bits)
1556 break;
1557 timeout--;
1558 }
1559
1560 if (timeout == 0)
1561 printf("%s: WARNING: timeout during codec detection; "
1562 "codecs might be present but haven't interrupted\n",
1563 device_xname(&sc->sc_dev));
1564
1565 /* disable all interrupts for now */
1566 auixp_disable_interrupts(sc);
1567
1568 /* Attach AC97 host interfaces */
1569 for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) {
1570 codec = &sc->sc_codec[codec_nr];
1571 memset(codec, 0, sizeof(struct auixp_codec));
1572
1573 codec->sc = sc;
1574 codec->codec_nr = codec_nr;
1575 codec->present = 0;
1576
1577 codec->host_if.arg = codec;
1578 codec->host_if.attach = auixp_attach_codec;
1579 codec->host_if.read = auixp_read_codec;
1580 codec->host_if.write = auixp_write_codec;
1581 codec->host_if.reset = auixp_reset_codec;
1582 codec->host_if.flags = auixp_flags_codec;
1583 }
1584
1585 if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC0_NOT_READY)) {
1586 /* codec 0 present */
1587 DPRINTF(("auixp : YAY! codec 0 present!\n"));
1588 if (ac97_attach(&sc->sc_codec[0].host_if, &sc->sc_dev,
1589 &sc->sc_lock) == 0)
1590 sc->sc_num_codecs++;
1591 }
1592
1593 if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC1_NOT_READY)) {
1594 /* codec 1 present */
1595 DPRINTF(("auixp : YAY! codec 1 present!\n"));
1596 if (ac97_attach(&sc->sc_codec[1].host_if, &sc->sc_dev,
1597 &sc->sc_lock) == 0)
1598 sc->sc_num_codecs++;
1599 }
1600
1601 if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC2_NOT_READY)) {
1602 /* codec 2 present */
1603 DPRINTF(("auixp : YAY! codec 2 present!\n"));
1604 if (ac97_attach(&sc->sc_codec[2].host_if, &sc->sc_dev,
1605 &sc->sc_lock) == 0)
1606 sc->sc_num_codecs++;
1607 }
1608
1609 if (sc->sc_num_codecs == 0) {
1610 printf("%s: no codecs detected or "
1611 "no codecs managed to initialise\n",
1612 device_xname(&sc->sc_dev));
1613 return;
1614 }
1615
1616 }
1617
1618
1619
1620 /* initialisation routines */
1621
1622 static void
1623 auixp_disable_dma(struct auixp_softc *sc, struct auixp_dma *dma)
1624 {
1625 bus_space_tag_t iot;
1626 bus_space_handle_t ioh;
1627 uint32_t value;
1628
1629 iot = sc->sc_iot;
1630 ioh = sc->sc_ioh;
1631 /* lets not stress the DMA engine more than nessisary */
1632 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1633 if (value & dma->dma_enable_bit) {
1634 value &= ~dma->dma_enable_bit;
1635 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1636 }
1637 }
1638
1639
1640 static void
1641 auixp_enable_dma(struct auixp_softc *sc, struct auixp_dma *dma)
1642 {
1643 bus_space_tag_t iot;
1644 bus_space_handle_t ioh;
1645 uint32_t value;
1646
1647 iot = sc->sc_iot;
1648 ioh = sc->sc_ioh;
1649 /* lets not stress the DMA engine more than nessisary */
1650 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1651 if (!(value & dma->dma_enable_bit)) {
1652 value |= dma->dma_enable_bit;
1653 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1654 }
1655 }
1656
1657
1658 static void
1659 auixp_reset_aclink(struct auixp_softc *sc)
1660 {
1661 bus_space_tag_t iot;
1662 bus_space_handle_t ioh;
1663 uint32_t value, timeout;
1664
1665 iot = sc->sc_iot;
1666 ioh = sc->sc_ioh;
1667
1668 /* if power is down, power it up */
1669 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1670 if (value & ATI_REG_CMD_POWERDOWN) {
1671 printf("%s: powering up\n", device_xname(&sc->sc_dev));
1672
1673 /* explicitly enable power */
1674 value &= ~ATI_REG_CMD_POWERDOWN;
1675 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1676
1677 /* have to wait at least 10 usec for it to initialise */
1678 DELAY(20);
1679 };
1680
1681 printf("%s: soft resetting aclink\n", device_xname(&sc->sc_dev));
1682
1683 /* perform a soft reset */
1684 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1685 value |= ATI_REG_CMD_AC_SOFT_RESET;
1686 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1687
1688 /* need to read the CMD reg and wait aprox. 10 usec to init */
1689 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1690 DELAY(20);
1691
1692 /* clear soft reset flag again */
1693 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1694 value &= ~ATI_REG_CMD_AC_SOFT_RESET;
1695 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1696
1697 /* check if the ac-link is working; reset device otherwise */
1698 timeout = 10;
1699 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1700 while (!(value & ATI_REG_CMD_ACLINK_ACTIVE)) {
1701 printf("%s: not up; resetting aclink hardware\n",
1702 device_xname(&sc->sc_dev));
1703
1704 /* dip aclink reset but keep the acsync */
1705 value &= ~ATI_REG_CMD_AC_RESET;
1706 value |= ATI_REG_CMD_AC_SYNC;
1707 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1708
1709 /* need to read CMD again and wait again (clocking in issue?) */
1710 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1711 DELAY(20);
1712
1713 /* assert aclink reset again */
1714 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1715 value |= ATI_REG_CMD_AC_RESET;
1716 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1717
1718 /* check if its active now */
1719 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1720
1721 timeout--;
1722 if (timeout == 0) break;
1723 };
1724
1725 if (timeout == 0) {
1726 printf("%s: giving up aclink reset\n", device_xname(&sc->sc_dev));
1727 };
1728 if (timeout != 10) {
1729 printf("%s: aclink hardware reset successful\n",
1730 device_xname(&sc->sc_dev));
1731 };
1732
1733 /* assert reset and sync for safety */
1734 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1735 value |= ATI_REG_CMD_AC_SYNC | ATI_REG_CMD_AC_RESET;
1736 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1737 }
1738
1739
1740 /* chip hard init */
1741 static int
1742 auixp_init(struct auixp_softc *sc)
1743 {
1744 bus_space_tag_t iot;
1745 bus_space_handle_t ioh;
1746 uint32_t value;
1747
1748 iot = sc->sc_iot;
1749 ioh = sc->sc_ioh;
1750 /* disable all interrupts and clear all sources */
1751 auixp_disable_interrupts(sc);
1752
1753 /* clear all DMA enables (preserving rest of settings) */
1754 value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
1755 value &= ~( ATI_REG_CMD_IN_DMA_EN |
1756 ATI_REG_CMD_OUT_DMA_EN |
1757 ATI_REG_CMD_SPDF_OUT_EN );
1758 bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
1759
1760 /* Reset AC-link */
1761 auixp_reset_aclink(sc);
1762
1763 /*
1764 * codecs get auto-detected later
1765 *
1766 * note: we are NOT enabling interrupts yet, no codecs have been
1767 * detected yet nor is anything else set up
1768 */
1769
1770 return 0;
1771 }
1772
1773 static bool
1774 auixp_resume(device_t dv, const pmf_qual_t *qual)
1775 {
1776 struct auixp_softc *sc = device_private(dv);
1777
1778 mutex_enter(&sc->sc_lock);
1779 auixp_reset_codec(sc);
1780 delay(1000);
1781 (sc->sc_codec[0].codec_if->vtbl->restore_ports)(sc->sc_codec[0].codec_if);
1782 mutex_exit(&sc->sc_lock);
1783
1784 return true;
1785 }
1786
1787 #ifdef DEBUG_AUIXP
1788
1789 static void
1790 auixp_dumpreg(void)
1791 {
1792 struct auixp_softc *sc;
1793 bus_space_tag_t iot;
1794 bus_space_handle_t ioh;
1795 int i;
1796
1797 sc = static_sc;
1798 iot = sc->sc_iot;
1799 ioh = sc->sc_ioh;
1800 printf("%s register dump:\n", device_xname(&sc->sc_dev));
1801 for (i = 0; i < 256; i+=4) {
1802 printf("\t0x%02x: 0x%08x\n", i, bus_space_read_4(iot, ioh, i));
1803 }
1804 printf("\n");
1805 }
1806 #endif
1807
1808 static void
1809 auixp_get_locks(void *addr, kmutex_t **intr, kmutex_t **proc)
1810 {
1811 struct auixp_codec *co = addr;
1812 struct auixp_softc *sc = co->sc;
1813
1814 *intr = &sc->sc_intr_lock;
1815 *proc = &sc->sc_lock;
1816 }
1817