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