a6984639665f1abc78372eb1cae047905909665a
[dragonfly.git] / sys / dev / sound / pci / atiixp.c
1 /*-
2  * Copyright (c) 2005 Ariff Abdullah <ariff@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THEPOSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/sound/pci/atiixp.c,v 1.2.2.8 2007/11/06 02:08:25 ariff Exp $
27  */
28
29 /*
30  * FreeBSD pcm driver for ATI IXP 150/200/250/300 AC97 controllers
31  *
32  * Features
33  *      * 16bit playback / recording
34  *      * 32bit native playback - yay!
35  *      * 32bit native recording (seems broken on few hardwares)
36  *
37  * Issues / TODO:
38  *      * SPDIF
39  *      * Support for more than 2 channels.
40  *      * VRA ? VRM ? DRA ?
41  *      * 32bit native recording seems broken on few hardwares, most
42  *        probably because of incomplete VRA/DRA cleanup.
43  *
44  *
45  * Thanks goes to:
46  *
47  *   Shaharil @ SCAN Associates whom relentlessly providing me the
48  *   mind blowing Acer Ferrari 4002 WLMi with this ATI IXP hardware.
49  *
50  *   Reinoud Zandijk <reinoud@NetBSD.org> (auixp), which this driver is
51  *   largely based upon although large part of it has been reworked. His
52  *   driver is the primary reference and pretty much well documented.
53  *
54  *   Takashi Iwai (ALSA snd-atiixp), for register definitions and some
55  *   random ninja hackery.
56  */
57
58 #include <dev/sound/pcm/sound.h>
59 #include <dev/sound/pcm/ac97.h>
60
61 #include <bus/pci/pcireg.h>
62 #include <bus/pci/pcivar.h>
63 #include <sys/sysctl.h>
64 #include <sys/endian.h>
65
66 #include <dev/sound/pci/atiixp.h>
67
68 struct atiixp_dma_op {
69         volatile uint32_t addr;
70         volatile uint16_t status;
71         volatile uint16_t size;
72         volatile uint32_t next;
73 };
74
75 struct atiixp_info;
76
77 struct atiixp_chinfo {
78         struct snd_dbuf *buffer;
79         struct pcm_channel *channel;
80         struct atiixp_info *parent;
81         struct atiixp_dma_op *sgd_table;
82         bus_addr_t sgd_addr;
83         uint32_t enable_bit, flush_bit, linkptr_bit, dma_dt_cur_bit;
84         uint32_t dma_segs;
85         uint32_t fmt;
86         int caps_32bit, dir, active;
87 };
88
89 struct atiixp_info {
90         device_t dev;
91
92         bus_space_tag_t st;
93         bus_space_handle_t sh;
94         bus_dma_tag_t parent_dmat;
95         bus_dma_tag_t sgd_dmat;
96         bus_dmamap_t sgd_dmamap;
97         bus_addr_t sgd_addr;
98
99         struct resource *reg, *irq;
100         int regtype, regid, irqid;
101         void *ih;
102         struct ac97_info *codec;
103
104         struct atiixp_chinfo pch;
105         struct atiixp_chinfo rch;
106         struct atiixp_dma_op *sgd_table;
107         struct intr_config_hook delayed_attach;
108
109         uint32_t bufsz;
110         uint32_t codec_not_ready_bits, codec_idx, codec_found;
111         uint32_t dma_segs;
112         int registered_channels;
113
114         sndlock_t       lock;
115 };
116
117 #define atiixp_rd(_sc, _reg)    \
118                 bus_space_read_4((_sc)->st, (_sc)->sh, _reg)
119 #define atiixp_wr(_sc, _reg, _val)      \
120                 bus_space_write_4((_sc)->st, (_sc)->sh, _reg, _val)
121
122 #define atiixp_lock(_sc)        snd_mtxlock((_sc)->lock)
123 #define atiixp_unlock(_sc)      snd_mtxunlock((_sc)->lock)
124 #define atiixp_assert(_sc)      snd_mtxassert((_sc)->lock)
125
126 static uint32_t atiixp_fmt_32bit[] = {
127         AFMT_STEREO | AFMT_S16_LE,
128         AFMT_STEREO | AFMT_S32_LE,
129         0
130 };
131
132 static uint32_t atiixp_fmt[] = {
133         AFMT_STEREO | AFMT_S16_LE,
134         0
135 };
136
137 static struct pcmchan_caps atiixp_caps_32bit = {
138         ATI_IXP_BASE_RATE,
139         ATI_IXP_BASE_RATE,
140         atiixp_fmt_32bit, 0
141 };
142
143 static struct pcmchan_caps atiixp_caps = {
144         ATI_IXP_BASE_RATE, 
145         ATI_IXP_BASE_RATE,
146         atiixp_fmt, 0
147 };
148
149 static const struct {
150         uint16_t vendor;
151         uint16_t devid;
152         char     *desc;
153 } atiixp_hw[] = {
154         { ATI_VENDOR_ID, ATI_IXP_200_ID, "ATI IXP 200" },
155         { ATI_VENDOR_ID, ATI_IXP_300_ID, "ATI IXP 300" },
156         { ATI_VENDOR_ID, ATI_IXP_400_ID, "ATI IXP 400" },
157         { ATI_VENDOR_ID, ATI_IXP_SB600_ID, "ATI IXP SB600" },
158 };
159
160 static void atiixp_enable_interrupts(struct atiixp_info *);
161 static void atiixp_disable_interrupts(struct atiixp_info *);
162 static void atiixp_reset_aclink(struct atiixp_info *);
163 static void atiixp_flush_dma(struct atiixp_info *, struct atiixp_chinfo *);
164 static void atiixp_enable_dma(struct atiixp_info *, struct atiixp_chinfo *);
165 static void atiixp_disable_dma(struct atiixp_info *, struct atiixp_chinfo *);
166
167 static int atiixp_waitready_codec(struct atiixp_info *);
168 static int atiixp_rdcd(kobj_t, void *, int);
169 static int atiixp_wrcd(kobj_t, void *, int, uint32_t);
170
171 static void  *atiixp_chan_init(kobj_t, void *, struct snd_dbuf *,
172                                                 struct pcm_channel *, int);
173 static int    atiixp_chan_setformat(kobj_t, void *, uint32_t);
174 static int    atiixp_chan_setspeed(kobj_t, void *, uint32_t);
175 static int    atiixp_chan_setblocksize(kobj_t, void *, uint32_t);
176 static void   atiixp_buildsgdt(struct atiixp_chinfo *);
177 static int    atiixp_chan_trigger(kobj_t, void *, int);
178 static int    atiixp_chan_getptr(kobj_t, void *);
179 static struct pcmchan_caps *atiixp_chan_getcaps(kobj_t, void *);
180
181 static void atiixp_intr(void *);
182 static void atiixp_dma_cb(void *, bus_dma_segment_t *, int, int);
183 static void atiixp_chip_pre_init(struct atiixp_info *);
184 static void atiixp_chip_post_init(void *);
185 static void atiixp_release_resource(struct atiixp_info *);
186 static int  atiixp_pci_probe(device_t);
187 static int  atiixp_pci_attach(device_t);
188 static int  atiixp_pci_detach(device_t);
189 static int  atiixp_pci_suspend(device_t);
190 static int  atiixp_pci_resume(device_t);
191
192 /*
193  * ATI IXP helper functions
194  */
195 static void
196 atiixp_enable_interrupts(struct atiixp_info *sc)
197 {
198         uint32_t value;
199
200         /* clear all pending */
201         atiixp_wr(sc, ATI_REG_ISR, 0xffffffff);
202
203         /* enable all relevant interrupt sources we can handle */
204         value = atiixp_rd(sc, ATI_REG_IER);
205
206         value |= ATI_REG_IER_IO_STATUS_EN;
207
208         /*
209          * Disable / ignore internal xrun/spdf interrupt flags
210          * since it doesn't interest us (for now).
211          */
212 #if 0
213         value |= ATI_REG_IER_IN_XRUN_EN;
214         value |= ATI_REG_IER_OUT_XRUN_EN;
215
216         value |= ATI_REG_IER_SPDF_XRUN_EN;
217         value |= ATI_REG_IER_SPDF_STATUS_EN;
218 #endif
219
220         atiixp_wr(sc, ATI_REG_IER, value);
221 }
222
223 static void
224 atiixp_disable_interrupts(struct atiixp_info *sc)
225 {
226         /* disable all interrupt sources */
227         atiixp_wr(sc, ATI_REG_IER, 0);
228
229         /* clear all pending */
230         atiixp_wr(sc, ATI_REG_ISR, 0xffffffff);
231 }
232
233 static void
234 atiixp_reset_aclink(struct atiixp_info *sc)
235 {
236         uint32_t value, timeout;
237
238         /* if power is down, power it up */
239         value = atiixp_rd(sc, ATI_REG_CMD);
240         if (value & ATI_REG_CMD_POWERDOWN) {
241                 /* explicitly enable power */
242                 value &= ~ATI_REG_CMD_POWERDOWN;
243                 atiixp_wr(sc, ATI_REG_CMD, value);
244
245                 /* have to wait at least 10 usec for it to initialise */
246                 DELAY(20);
247         };
248
249         /* perform a soft reset */
250         value  = atiixp_rd(sc, ATI_REG_CMD);
251         value |= ATI_REG_CMD_AC_SOFT_RESET;
252         atiixp_wr(sc, ATI_REG_CMD, value);
253
254         /* need to read the CMD reg and wait aprox. 10 usec to init */
255         value  = atiixp_rd(sc, ATI_REG_CMD);
256         DELAY(20);
257
258         /* clear soft reset flag again */
259         value  = atiixp_rd(sc, ATI_REG_CMD);
260         value &= ~ATI_REG_CMD_AC_SOFT_RESET;
261         atiixp_wr(sc, ATI_REG_CMD, value);
262
263         /* check if the ac-link is working; reset device otherwise */
264         timeout = 10;
265         value = atiixp_rd(sc, ATI_REG_CMD);
266         while (!(value & ATI_REG_CMD_ACLINK_ACTIVE)
267                                                 && --timeout) {
268 #if 0
269                 device_printf(sc->dev, "not up; resetting aclink hardware\n");
270 #endif
271
272                 /* dip aclink reset but keep the acsync */
273                 value &= ~ATI_REG_CMD_AC_RESET;
274                 value |=  ATI_REG_CMD_AC_SYNC;
275                 atiixp_wr(sc, ATI_REG_CMD, value);
276
277                 /* need to read CMD again and wait again (clocking in issue?) */
278                 value = atiixp_rd(sc, ATI_REG_CMD);
279                 DELAY(20);
280
281                 /* assert aclink reset again */
282                 value = atiixp_rd(sc, ATI_REG_CMD);
283                 value |=  ATI_REG_CMD_AC_RESET;
284                 atiixp_wr(sc, ATI_REG_CMD, value);
285
286                 /* check if its active now */
287                 value = atiixp_rd(sc, ATI_REG_CMD);
288         };
289
290         if (timeout == 0)
291                 device_printf(sc->dev, "giving up aclink reset\n");
292 #if 0
293         if (timeout != 10)
294                 device_printf(sc->dev, "aclink hardware reset successful\n");
295 #endif
296
297         /* assert reset and sync for safety */
298         value  = atiixp_rd(sc, ATI_REG_CMD);
299         value |= ATI_REG_CMD_AC_SYNC | ATI_REG_CMD_AC_RESET;
300         atiixp_wr(sc, ATI_REG_CMD, value);
301 }
302
303 static void
304 atiixp_flush_dma(struct atiixp_info *sc, struct atiixp_chinfo *ch)
305 {
306         atiixp_wr(sc, ATI_REG_FIFO_FLUSH, ch->flush_bit);
307 }
308
309 static void
310 atiixp_enable_dma(struct atiixp_info *sc, struct atiixp_chinfo *ch)
311 {
312         uint32_t value;
313
314         value = atiixp_rd(sc, ATI_REG_CMD);
315         if (!(value & ch->enable_bit)) {
316                 value |= ch->enable_bit;
317                 atiixp_wr(sc, ATI_REG_CMD, value);
318         }
319 }
320
321 static void 
322 atiixp_disable_dma(struct atiixp_info *sc, struct atiixp_chinfo *ch)
323 {
324         uint32_t value;
325
326         value = atiixp_rd(sc, ATI_REG_CMD);
327         if (value & ch->enable_bit) {
328                 value &= ~ch->enable_bit;
329                 atiixp_wr(sc, ATI_REG_CMD, value);
330         }
331 }
332
333 /*
334  * AC97 interface
335  */
336 static int
337 atiixp_waitready_codec(struct atiixp_info *sc)
338 {
339         int timeout = 500;
340
341         do {
342                 if ((atiixp_rd(sc, ATI_REG_PHYS_OUT_ADDR) &
343                                 ATI_REG_PHYS_OUT_ADDR_EN) == 0)
344                         return 0;
345                 DELAY(1);
346         } while (timeout--);
347
348         return -1;
349 }
350
351 static int
352 atiixp_rdcd(kobj_t obj, void *devinfo, int reg)
353 {
354         struct atiixp_info *sc = devinfo;
355         uint32_t data;
356         int timeout;
357
358         if (atiixp_waitready_codec(sc))
359                 return -1;
360
361         data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
362                         ATI_REG_PHYS_OUT_ADDR_EN |
363                         ATI_REG_PHYS_OUT_RW | sc->codec_idx;
364
365         atiixp_wr(sc, ATI_REG_PHYS_OUT_ADDR, data);
366
367         if (atiixp_waitready_codec(sc))
368                 return -1;
369
370         timeout = 500;
371         do {
372                 data = atiixp_rd(sc, ATI_REG_PHYS_IN_ADDR);
373                 if (data & ATI_REG_PHYS_IN_READ_FLAG)
374                         return data >> ATI_REG_PHYS_IN_DATA_SHIFT;
375                 DELAY(1);
376         } while (timeout--);
377
378         if (reg < 0x7c)
379                 device_printf(sc->dev, "codec read timeout! (reg 0x%x)\n", reg);
380
381         return -1;
382 }
383
384 static int
385 atiixp_wrcd(kobj_t obj, void *devinfo, int reg, uint32_t data)
386 {
387         struct atiixp_info *sc = devinfo;
388
389         if (atiixp_waitready_codec(sc))
390                 return -1;
391
392         data = (data << ATI_REG_PHYS_OUT_DATA_SHIFT) |
393                         (((uint32_t)reg) << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
394                         ATI_REG_PHYS_OUT_ADDR_EN | sc->codec_idx;
395
396         atiixp_wr(sc, ATI_REG_PHYS_OUT_ADDR, data);
397
398         return 0;
399 }
400
401 static kobj_method_t atiixp_ac97_methods[] = {
402         KOBJMETHOD(ac97_read,           atiixp_rdcd),
403         KOBJMETHOD(ac97_write,          atiixp_wrcd),
404         { 0, 0 }
405 };
406 AC97_DECLARE(atiixp_ac97);
407
408 /*
409  * Playback / Record channel interface
410  */
411 static void *
412 atiixp_chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
413                                         struct pcm_channel *c, int dir)
414 {
415         struct atiixp_info *sc = devinfo;
416         struct atiixp_chinfo *ch;
417         int num;
418
419         atiixp_lock(sc);
420
421         if (dir == PCMDIR_PLAY) {
422                 ch = &sc->pch;
423                 ch->linkptr_bit = ATI_REG_OUT_DMA_LINKPTR;
424                 ch->enable_bit = ATI_REG_CMD_OUT_DMA_EN | ATI_REG_CMD_SEND_EN;
425                 ch->flush_bit = ATI_REG_FIFO_OUT_FLUSH;
426                 ch->dma_dt_cur_bit = ATI_REG_OUT_DMA_DT_CUR;
427                 /* Native 32bit playback working properly */
428                 ch->caps_32bit = 1;
429         } else {
430                 ch = &sc->rch;
431                 ch->linkptr_bit = ATI_REG_IN_DMA_LINKPTR;
432                 ch->enable_bit = ATI_REG_CMD_IN_DMA_EN  | ATI_REG_CMD_RECEIVE_EN;
433                 ch->flush_bit = ATI_REG_FIFO_IN_FLUSH;
434                 ch->dma_dt_cur_bit = ATI_REG_IN_DMA_DT_CUR;
435                 /* XXX Native 32bit recording appear to be broken */
436                 ch->caps_32bit = 1;
437         }
438
439         ch->buffer = b;
440         ch->parent = sc;
441         ch->channel = c;
442         ch->dir = dir;
443         ch->dma_segs = sc->dma_segs;
444
445         atiixp_unlock(sc);
446
447         if (sndbuf_alloc(ch->buffer, sc->parent_dmat, sc->bufsz) == -1)
448                 return NULL;
449
450         atiixp_lock(sc);
451         num = sc->registered_channels++;
452         ch->sgd_table = &sc->sgd_table[num * ch->dma_segs];
453         ch->sgd_addr = sc->sgd_addr +
454                         (num * ch->dma_segs * sizeof(struct atiixp_dma_op));
455         atiixp_disable_dma(sc, ch);
456         atiixp_unlock(sc);
457
458         return ch;
459 }
460
461 static int
462 atiixp_chan_setformat(kobj_t obj, void *data, uint32_t format)
463 {
464         struct atiixp_chinfo *ch = data;
465         struct atiixp_info *sc = ch->parent;
466         uint32_t value;
467
468         atiixp_lock(sc);
469         if (ch->dir == PCMDIR_REC) {
470                 value = atiixp_rd(sc, ATI_REG_CMD);
471                 value &= ~ATI_REG_CMD_INTERLEAVE_IN;
472                 if ((format & AFMT_32BIT) == 0)
473                         value |= ATI_REG_CMD_INTERLEAVE_IN;
474                 atiixp_wr(sc, ATI_REG_CMD, value);
475         } else {
476                 value = atiixp_rd(sc, ATI_REG_OUT_DMA_SLOT);
477                 value &= ~ATI_REG_OUT_DMA_SLOT_MASK;
478                 /* We do not have support for more than 2 channels, _yet_. */
479                 value |= ATI_REG_OUT_DMA_SLOT_BIT(3) |
480                                 ATI_REG_OUT_DMA_SLOT_BIT(4);
481                 value |= 0x04 << ATI_REG_OUT_DMA_THRESHOLD_SHIFT;
482                 atiixp_wr(sc, ATI_REG_OUT_DMA_SLOT, value);
483                 value = atiixp_rd(sc, ATI_REG_CMD);
484                 value &= ~ATI_REG_CMD_INTERLEAVE_OUT;
485                 if ((format & AFMT_32BIT) == 0)
486                         value |= ATI_REG_CMD_INTERLEAVE_OUT;
487                 atiixp_wr(sc, ATI_REG_CMD, value);
488                 value = atiixp_rd(sc, ATI_REG_6CH_REORDER);
489                 value &= ~ATI_REG_6CH_REORDER_EN;
490                 atiixp_wr(sc, ATI_REG_6CH_REORDER, value);
491         }
492         ch->fmt = format;
493         atiixp_unlock(sc);
494
495         return 0;
496 }
497
498 static int
499 atiixp_chan_setspeed(kobj_t obj, void *data, uint32_t spd)
500 {
501         /* XXX We're supposed to do VRA/DRA processing right here */
502         return ATI_IXP_BASE_RATE;
503 }
504
505 static int
506 atiixp_chan_setblocksize(kobj_t obj, void *data, uint32_t blksz)
507 {
508         struct atiixp_chinfo *ch = data;
509         struct atiixp_info *sc = ch->parent;
510
511         if (blksz > (sc->bufsz / ch->dma_segs))
512                 blksz = sc->bufsz / ch->dma_segs;
513
514         sndbuf_resize(ch->buffer, ch->dma_segs, blksz);
515
516         return sndbuf_getblksz(ch->buffer);
517 }
518
519 static void
520 atiixp_buildsgdt(struct atiixp_chinfo *ch)
521 {
522         uint32_t addr, blksz;
523         int i;
524
525         addr = sndbuf_getbufaddr(ch->buffer);
526         blksz = sndbuf_getblksz(ch->buffer);
527
528         for (i = 0; i < ch->dma_segs; i++) {
529                 ch->sgd_table[i].addr = htole32(addr + (i * blksz));
530                 ch->sgd_table[i].status = htole16(0);
531                 ch->sgd_table[i].size = htole16(blksz >> 2);
532                 ch->sgd_table[i].next = htole32((uint32_t)ch->sgd_addr + 
533                                                 (((i + 1) % ch->dma_segs) *
534                                                 sizeof(struct atiixp_dma_op)));
535         }
536 }
537
538 static int
539 atiixp_chan_trigger(kobj_t obj, void *data, int go)
540 {
541         struct atiixp_chinfo *ch = data;
542         struct atiixp_info *sc = ch->parent;
543         uint32_t value;
544
545         atiixp_lock(sc);
546
547         switch (go) {
548                 case PCMTRIG_START:
549                         atiixp_flush_dma(sc, ch);
550                         atiixp_buildsgdt(ch);
551                         atiixp_wr(sc, ch->linkptr_bit, 0);
552                         atiixp_enable_dma(sc, ch);
553                         atiixp_wr(sc, ch->linkptr_bit,
554                                 (uint32_t)ch->sgd_addr | ATI_REG_LINKPTR_EN);
555                         break;
556                 case PCMTRIG_STOP:
557                 case PCMTRIG_ABORT:
558                         atiixp_disable_dma(sc, ch);
559                         atiixp_flush_dma(sc, ch);
560                         break;
561                 default:
562                         atiixp_unlock(sc);
563                         return 0;
564                         break;
565         }
566
567         /* Update bus busy status */
568         value = atiixp_rd(sc, ATI_REG_IER);
569         if (atiixp_rd(sc, ATI_REG_CMD) & (
570                         ATI_REG_CMD_SEND_EN | ATI_REG_CMD_RECEIVE_EN |
571                         ATI_REG_CMD_SPDF_OUT_EN))
572                 value |= ATI_REG_IER_SET_BUS_BUSY;
573         else
574                 value &= ~ATI_REG_IER_SET_BUS_BUSY;
575         atiixp_wr(sc, ATI_REG_IER, value);
576
577         atiixp_unlock(sc);
578
579         return 0;
580 }
581
582 static int
583 atiixp_chan_getptr(kobj_t obj, void *data)
584 {
585         struct atiixp_chinfo *ch = data;
586         struct atiixp_info *sc = ch->parent;
587         uint32_t addr, align, retry, sz;
588         volatile uint32_t ptr;
589
590         addr = sndbuf_getbufaddr(ch->buffer);
591         align = (ch->fmt & AFMT_32BIT) ? 7 : 3;
592         retry = 100;
593         sz = sndbuf_getblksz(ch->buffer) * ch->dma_segs;
594
595         atiixp_lock(sc);
596         do {
597                 ptr = atiixp_rd(sc, ch->dma_dt_cur_bit);
598                 if (ptr < addr)
599                         continue;
600                 ptr -= addr;
601                 if (ptr < sz && !(ptr & align))
602                         break;
603         } while (--retry);
604         atiixp_unlock(sc);
605
606 #if 0
607         if (retry != 100) {
608                 device_printf(sc->dev,
609                     "%saligned hwptr: dir=PCMDIR_%s ptr=%u fmt=0x%08x retry=%d\n",
610                     (ptr & align) ? "un" : "",
611                     (ch->dir == PCMDIR_PLAY) ? "PLAY" : "REC", ptr,
612                     ch->fmt, 100 - retry);
613         }
614 #endif
615
616         return (retry > 0) ? ptr : 0;
617 }
618
619 static struct pcmchan_caps *
620 atiixp_chan_getcaps(kobj_t obj, void *data)
621 {
622         struct atiixp_chinfo *ch = data;
623
624         if (ch->caps_32bit)
625                 return &atiixp_caps_32bit;
626         return &atiixp_caps;
627 }
628
629 static kobj_method_t atiixp_chan_methods[] = {
630         KOBJMETHOD(channel_init,                atiixp_chan_init),
631         KOBJMETHOD(channel_setformat,           atiixp_chan_setformat),
632         KOBJMETHOD(channel_setspeed,            atiixp_chan_setspeed),
633         KOBJMETHOD(channel_setblocksize,        atiixp_chan_setblocksize),
634         KOBJMETHOD(channel_trigger,             atiixp_chan_trigger),
635         KOBJMETHOD(channel_getptr,              atiixp_chan_getptr),
636         KOBJMETHOD(channel_getcaps,             atiixp_chan_getcaps),
637         { 0, 0 }
638 };
639 CHANNEL_DECLARE(atiixp_chan);
640
641 /*
642  * PCI driver interface
643  */
644 static void
645 atiixp_intr(void *p)
646 {
647         struct atiixp_info *sc = p;
648         uint32_t status, enable, detected_codecs;
649
650         atiixp_lock(sc);
651         status = atiixp_rd(sc, ATI_REG_ISR);
652
653         if (status == 0) {
654                 atiixp_unlock(sc);
655                 return;
656         }
657
658         if ((status & ATI_REG_ISR_IN_STATUS) && sc->rch.channel) {
659                 atiixp_unlock(sc);
660                 chn_intr(sc->rch.channel);
661                 atiixp_lock(sc);
662         }
663         if ((status & ATI_REG_ISR_OUT_STATUS) && sc->pch.channel) {
664                 atiixp_unlock(sc);
665                 chn_intr(sc->pch.channel);
666                 atiixp_lock(sc);
667         }
668
669 #if 0
670         if (status & ATI_REG_ISR_IN_XRUN) {
671                 device_printf(sc->dev,
672                         "Receive IN XRUN interrupt\n");
673         }
674         if (status & ATI_REG_ISR_OUT_XRUN) {
675                 device_printf(sc->dev,
676                         "Receive OUT XRUN interrupt\n");
677         }
678 #endif
679
680         if (status & CODEC_CHECK_BITS) {
681                 /* mark missing codecs as not ready */
682                 detected_codecs = status & CODEC_CHECK_BITS;
683                 sc->codec_not_ready_bits |= detected_codecs;
684
685                 /* disable detected interupt sources */
686                 enable  = atiixp_rd(sc, ATI_REG_IER);
687                 enable &= ~detected_codecs;
688                 atiixp_wr(sc, ATI_REG_IER, enable);
689         }
690
691         /* acknowledge */
692         atiixp_wr(sc, ATI_REG_ISR, status);
693         atiixp_unlock(sc);
694 }
695
696 static void
697 atiixp_dma_cb(void *p, bus_dma_segment_t *bds, int a, int b)
698 {
699         struct atiixp_info *sc = (struct atiixp_info *)p;
700         sc->sgd_addr = bds->ds_addr;
701 }
702
703 static void
704 atiixp_chip_pre_init(struct atiixp_info *sc)
705 {
706         uint32_t value;
707
708         atiixp_lock(sc);
709
710         /* disable interrupts */
711         atiixp_disable_interrupts(sc);
712
713         /* clear all DMA enables (preserving rest of settings) */
714         value = atiixp_rd(sc, ATI_REG_CMD);
715         value &= ~(ATI_REG_CMD_IN_DMA_EN | ATI_REG_CMD_OUT_DMA_EN |
716                                                 ATI_REG_CMD_SPDF_OUT_EN );
717         atiixp_wr(sc, ATI_REG_CMD, value);
718
719         /* reset aclink */
720         atiixp_reset_aclink(sc);
721
722         sc->codec_not_ready_bits = 0;
723
724         /* enable all codecs to interrupt as well as the new frame interrupt */
725         atiixp_wr(sc, ATI_REG_IER, CODEC_CHECK_BITS);
726
727         atiixp_unlock(sc);
728 }
729
730 static void
731 atiixp_chip_post_init(void *arg)
732 {
733         struct atiixp_info *sc = (struct atiixp_info *)arg;
734         uint32_t subdev;
735         int i, timeout, found;
736         char status[SND_STATUSLEN];
737
738         atiixp_lock(sc);
739
740         if (sc->delayed_attach.ich_func) {
741                 config_intrhook_disestablish(&sc->delayed_attach);
742                 sc->delayed_attach.ich_func = NULL;
743         }
744
745         /* wait for the interrupts to happen */
746         timeout = 100;
747         while (--timeout) {
748                 snd_mtxsleep(sc, sc->lock, 0, "ixpslp", 1);
749                 if (sc->codec_not_ready_bits)
750                         break;
751         }
752
753         atiixp_disable_interrupts(sc);
754
755         if (timeout == 0) {
756                 device_printf(sc->dev,
757                         "WARNING: timeout during codec detection; "
758                         "codecs might be present but haven't interrupted\n");
759                 atiixp_unlock(sc);
760                 goto postinitbad;
761         }
762
763         found = 0;
764
765         /*
766          * ATI IXP can have upto 3 codecs, but single codec should be
767          * suffice for now.
768          */
769         if (!(sc->codec_not_ready_bits &
770                                 ATI_REG_ISR_CODEC0_NOT_READY)) {
771                 /* codec 0 present */
772                 sc->codec_found++;
773                 sc->codec_idx = 0;
774                 found++;
775         }
776
777         if (!(sc->codec_not_ready_bits &
778                                 ATI_REG_ISR_CODEC1_NOT_READY)) {
779                 /* codec 1 present */
780                 sc->codec_found++;
781         }
782
783         if (!(sc->codec_not_ready_bits &
784                                 ATI_REG_ISR_CODEC2_NOT_READY)) {
785                 /* codec 2 present */
786                 sc->codec_found++;
787         }
788
789         atiixp_unlock(sc);
790
791         if (found == 0)
792                 goto postinitbad;
793
794         /* create/init mixer */
795         sc->codec = AC97_CREATE(sc->dev, sc, atiixp_ac97);
796         if (sc->codec == NULL)
797                 goto postinitbad;
798
799         subdev = (pci_get_subdevice(sc->dev) << 16) | pci_get_subvendor(sc->dev);
800         switch (subdev) {
801         case 0x11831043:        /* ASUS A6R */
802         case 0x2043161f:        /* Maxselect x710s - http://maxselect.ru/ */
803                 ac97_setflags(sc->codec, ac97_getflags(sc->codec) | AC97_F_EAPD_INV);
804                 break;
805         default:
806                 break;
807         }
808
809         mixer_init(sc->dev, ac97_getmixerclass(), sc->codec);
810
811         if (pcm_register(sc->dev, sc, ATI_IXP_NPCHAN, ATI_IXP_NRCHAN))
812                 goto postinitbad;
813
814         for (i = 0; i < ATI_IXP_NPCHAN; i++)
815                 pcm_addchan(sc->dev, PCMDIR_PLAY, &atiixp_chan_class, sc);
816         for (i = 0; i < ATI_IXP_NRCHAN; i++)
817                 pcm_addchan(sc->dev, PCMDIR_REC, &atiixp_chan_class, sc);
818
819         ksnprintf(status, SND_STATUSLEN, "at memory 0x%lx irq %ld %s", 
820                         rman_get_start(sc->reg), rman_get_start(sc->irq),
821                         PCM_KLDSTRING(snd_atiixp));
822
823         pcm_setstatus(sc->dev, status);
824
825         atiixp_lock(sc);
826         atiixp_enable_interrupts(sc);
827         atiixp_unlock(sc);
828
829         return;
830
831 postinitbad:
832         atiixp_release_resource(sc);
833 }
834
835 static void
836 atiixp_release_resource(struct atiixp_info *sc)
837 {
838         if (sc == NULL)
839                 return;
840         if (sc->codec) {
841                 ac97_destroy(sc->codec);
842                 sc->codec = NULL;
843         }
844         if (sc->ih) {
845                 bus_teardown_intr(sc->dev, sc->irq, sc->ih);
846                 sc->ih = NULL;
847         }
848         if (sc->reg) {
849                 bus_release_resource(sc->dev, sc->regtype, sc->regid, sc->reg);
850                 sc->reg = NULL;
851         }
852         if (sc->irq) {
853                 bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irqid, sc->irq);
854                 sc->irq = NULL;
855         }
856         if (sc->parent_dmat) {
857                 bus_dma_tag_destroy(sc->parent_dmat);
858                 sc->parent_dmat = NULL;
859         }
860         if (sc->sgd_dmamap)
861                 bus_dmamap_unload(sc->sgd_dmat, sc->sgd_dmamap);
862         if (sc->sgd_table) {
863                 bus_dmamem_free(sc->sgd_dmat, sc->sgd_table, sc->sgd_dmamap);
864                 sc->sgd_table = NULL;
865         }
866         sc->sgd_dmamap = NULL;
867         if (sc->sgd_dmat) {
868                 bus_dma_tag_destroy(sc->sgd_dmat);
869                 sc->sgd_dmat = NULL;
870         }
871         if (sc->lock) {
872                 snd_mtxfree(sc->lock);
873                 sc->lock = NULL;
874         }
875 }
876
877 static int
878 atiixp_pci_probe(device_t dev)
879 {
880         int i;
881         uint16_t devid, vendor;
882
883         vendor = pci_get_vendor(dev);
884         devid = pci_get_device(dev);
885         for (i = 0; i < NELEM(atiixp_hw); i++) {
886                 if (vendor == atiixp_hw[i].vendor &&
887                                         devid == atiixp_hw[i].devid) {
888                         device_set_desc(dev, atiixp_hw[i].desc);
889                         return BUS_PROBE_DEFAULT;
890                 }
891         }
892
893         return ENXIO;
894 }
895
896 static int
897 atiixp_pci_attach(device_t dev)
898 {
899         struct atiixp_info *sc;
900         int i;
901
902         sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
903         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "sound softc");
904         sc->dev = dev;
905         /*
906          * Default DMA segments per playback / recording channel
907          */
908         sc->dma_segs = ATI_IXP_DMA_CHSEGS;
909
910         pci_set_powerstate(dev, PCI_POWERSTATE_D0);
911         pci_enable_busmaster(dev);
912
913         sc->regid = PCIR_BAR(0);
914         sc->regtype = SYS_RES_MEMORY;
915         sc->reg = bus_alloc_resource_any(dev, sc->regtype, &sc->regid,
916                                                                 RF_ACTIVE);
917
918         if (!sc->reg) {
919                 device_printf(dev, "unable to allocate register space\n");
920                 goto bad;
921         }
922
923         sc->st = rman_get_bustag(sc->reg);
924         sc->sh = rman_get_bushandle(sc->reg);
925
926         sc->bufsz = pcm_getbuffersize(dev, 4096, ATI_IXP_DEFAULT_BUFSZ, 65536);
927
928         sc->irqid = 0;
929         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irqid,
930                                                 RF_ACTIVE | RF_SHAREABLE);
931         if (!sc->irq || 
932                         snd_setup_intr(dev, sc->irq, INTR_MPSAFE,
933                                                 atiixp_intr, sc, &sc->ih)) {
934                 device_printf(dev, "unable to map interrupt\n");
935                 goto bad;
936         }
937
938         /*
939          * Let the user choose the best DMA segments.
940          */
941          if (resource_int_value(device_get_name(dev),
942                         device_get_unit(dev), "dma_segs",
943                         &i) == 0) {
944                 if (i < ATI_IXP_DMA_CHSEGS_MIN)
945                         i = ATI_IXP_DMA_CHSEGS_MIN;
946                 if (i > ATI_IXP_DMA_CHSEGS_MAX)
947                         i = ATI_IXP_DMA_CHSEGS_MAX;
948                 sc->dma_segs = i;
949         }
950
951         /*
952          * round the value to the nearest ^2
953          */
954         i = 0;
955         while (sc->dma_segs >> i)
956                 i++;
957         sc->dma_segs = 1 << (i - 1);
958         if (sc->dma_segs < ATI_IXP_DMA_CHSEGS_MIN)
959                 sc->dma_segs = ATI_IXP_DMA_CHSEGS_MIN;
960         else if (sc->dma_segs > ATI_IXP_DMA_CHSEGS_MAX)
961                 sc->dma_segs = ATI_IXP_DMA_CHSEGS_MAX;
962
963         /*
964          * DMA tag for scatter-gather buffers and link pointers
965          */
966         if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
967                 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
968                 /*highaddr*/BUS_SPACE_MAXADDR,
969                 /*filter*/NULL, /*filterarg*/NULL,
970                 /*maxsize*/sc->bufsz, /*nsegments*/1, /*maxsegz*/0x3ffff,
971                 /*flags*/0,
972                 &sc->parent_dmat) != 0) {
973                 device_printf(dev, "unable to create dma tag\n");
974                 goto bad;
975         }
976
977         if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
978                 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
979                 /*highaddr*/BUS_SPACE_MAXADDR,
980                 /*filter*/NULL, /*filterarg*/NULL,
981                 /*maxsize*/sc->dma_segs * ATI_IXP_NCHANS *
982                                                 sizeof(struct atiixp_dma_op),
983                 /*nsegments*/1, /*maxsegz*/0x3ffff,
984                 /*flags*/0,
985                 &sc->sgd_dmat) != 0) {
986                 device_printf(dev, "unable to create dma tag\n");
987                 goto bad;
988         }
989
990         if (bus_dmamem_alloc(sc->sgd_dmat, (void **)&sc->sgd_table, 
991                                 BUS_DMA_NOWAIT, &sc->sgd_dmamap) == -1)
992                 goto bad;
993
994         if (bus_dmamap_load(sc->sgd_dmat, sc->sgd_dmamap, sc->sgd_table, 
995                                 sc->dma_segs * ATI_IXP_NCHANS *
996                                                 sizeof(struct atiixp_dma_op),
997                                 atiixp_dma_cb, sc, 0))
998                 goto bad;
999
1000
1001         atiixp_chip_pre_init(sc);
1002
1003         sc->delayed_attach.ich_func = atiixp_chip_post_init;
1004         sc->delayed_attach.ich_arg = sc;
1005         if (cold == 0 ||
1006                         config_intrhook_establish(&sc->delayed_attach) != 0) {
1007                 sc->delayed_attach.ich_func = NULL;
1008                 atiixp_chip_post_init(sc);
1009         }
1010
1011         return 0;
1012
1013 bad:
1014         atiixp_release_resource(sc);
1015         return ENXIO;
1016 }
1017
1018 static int
1019 atiixp_pci_detach(device_t dev)
1020 {
1021         int r;
1022         struct atiixp_info *sc;
1023
1024         sc = pcm_getdevinfo(dev);
1025         if (sc != NULL) {
1026                 if (sc->codec != NULL) {
1027                         r = pcm_unregister(dev);
1028                         if (r)
1029                                 return r;
1030                 }
1031                 sc->codec = NULL;
1032                 atiixp_disable_interrupts(sc);
1033                 atiixp_release_resource(sc);
1034                 kfree(sc, M_DEVBUF);
1035         }
1036         return 0;
1037 }
1038
1039 static int
1040 atiixp_pci_suspend(device_t dev)
1041 {
1042         struct atiixp_info *sc = pcm_getdevinfo(dev);
1043         uint32_t value;
1044
1045         /* quickly disable interrupts and save channels active state */
1046         atiixp_lock(sc);
1047         atiixp_disable_interrupts(sc);
1048         value = atiixp_rd(sc, ATI_REG_CMD);
1049         sc->pch.active = (value & ATI_REG_CMD_SEND_EN) ? 1 : 0;
1050         sc->rch.active = (value & ATI_REG_CMD_RECEIVE_EN) ? 1 : 0;
1051         atiixp_unlock(sc);
1052
1053         /* stop everything */
1054         if (sc->pch.channel && sc->pch.active)
1055                 atiixp_chan_trigger(NULL, &sc->pch, PCMTRIG_STOP);
1056         if (sc->rch.channel && sc->rch.active)
1057                 atiixp_chan_trigger(NULL, &sc->rch, PCMTRIG_STOP);
1058
1059         /* power down aclink and pci bus */
1060         atiixp_lock(sc);
1061         value = atiixp_rd(sc, ATI_REG_CMD);
1062         value |= ATI_REG_CMD_POWERDOWN | ATI_REG_CMD_AC_RESET;
1063         atiixp_wr(sc, ATI_REG_CMD, ATI_REG_CMD_POWERDOWN);
1064         pci_set_powerstate(dev, PCI_POWERSTATE_D3);
1065         atiixp_unlock(sc);
1066
1067         return 0;
1068 }
1069
1070 static int
1071 atiixp_pci_resume(device_t dev)
1072 {
1073         struct atiixp_info *sc = pcm_getdevinfo(dev);
1074
1075         atiixp_lock(sc);
1076         /* power up pci bus */
1077         pci_set_powerstate(dev, PCI_POWERSTATE_D0);
1078         pci_enable_io(dev, SYS_RES_MEMORY);
1079         pci_enable_busmaster(dev);
1080         /* reset / power up aclink */
1081         atiixp_reset_aclink(sc);
1082         atiixp_unlock(sc);
1083
1084         if (mixer_reinit(dev) == -1) {
1085                 device_printf(dev, "unable to reinitialize the mixer\n");
1086                 return ENXIO;
1087         }
1088
1089         /*
1090          * Resume channel activities. Reset channel format regardless
1091          * of its previous state.
1092          */
1093         if (sc->pch.channel) {
1094                 if (sc->pch.fmt)
1095                         atiixp_chan_setformat(NULL, &sc->pch, sc->pch.fmt);
1096                 if (sc->pch.active)
1097                         atiixp_chan_trigger(NULL, &sc->pch, PCMTRIG_START);
1098         }
1099         if (sc->rch.channel) {
1100                 if (sc->rch.fmt)
1101                         atiixp_chan_setformat(NULL, &sc->rch, sc->rch.fmt);
1102                 if (sc->rch.active)
1103                         atiixp_chan_trigger(NULL, &sc->rch, PCMTRIG_START);
1104         }
1105
1106         /* enable interrupts */
1107         atiixp_lock(sc);
1108         atiixp_enable_interrupts(sc);
1109         atiixp_unlock(sc);
1110
1111         return 0;
1112 }
1113
1114 static device_method_t atiixp_methods[] = {
1115         DEVMETHOD(device_probe,         atiixp_pci_probe),
1116         DEVMETHOD(device_attach,        atiixp_pci_attach),
1117         DEVMETHOD(device_detach,        atiixp_pci_detach),
1118         DEVMETHOD(device_suspend,       atiixp_pci_suspend),
1119         DEVMETHOD(device_resume,        atiixp_pci_resume),
1120         { 0, 0 }
1121 };
1122
1123 static driver_t atiixp_driver = {
1124         "pcm",
1125         atiixp_methods,
1126         PCM_SOFTC_SIZE,
1127 };
1128
1129 DRIVER_MODULE(snd_atiixp, pci, atiixp_driver, pcm_devclass, NULL, NULL);
1130 MODULE_DEPEND(snd_atiixp, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1131 MODULE_VERSION(snd_atiixp, 1);