Say hello to a sound system update from FreeBSD. This includes the long
[dragonfly.git] / sys / dev / sound / isa / sb8.c
1 /*-
2  * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
3  * Copyright 1997,1998 Luigi Rizzo.
4  *
5  * Derived from files in the Voxware 3.5 distribution,
6  * Copyright by Hannu Savolainen 1994, under the same copyright
7  * conditions.
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  * $FreeBSD: src/sys/dev/sound/isa/sb8.c,v 1.79.2.1 2005/12/30 19:55:53 netchild Exp $
32  * $DragonFly: src/sys/dev/sound/isa/sb8.c,v 1.7 2007/01/04 21:47:02 corecode Exp $
33  */
34
35 #include <dev/sound/pcm/sound.h>
36
37 #include  <dev/sound/isa/sb.h>
38 #include  <dev/sound/chip.h>
39
40 #include <bus/isa/isavar.h>
41
42 #include "mixer_if.h"
43
44 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/isa/sb8.c,v 1.7 2007/01/04 21:47:02 corecode Exp $");
45
46 #define SB_DEFAULT_BUFSZ        4096
47
48 static u_int32_t sb_fmt[] = {
49         AFMT_U8,
50         0
51 };
52 static struct pcmchan_caps sb200_playcaps = {4000, 23000, sb_fmt, 0};
53 static struct pcmchan_caps sb200_reccaps = {4000, 13000, sb_fmt, 0};
54 static struct pcmchan_caps sb201_playcaps = {4000, 44100, sb_fmt, 0};
55 static struct pcmchan_caps sb201_reccaps = {4000, 15000, sb_fmt, 0};
56
57 static u_int32_t sbpro_fmt[] = {
58         AFMT_U8,
59         AFMT_STEREO | AFMT_U8,
60         0
61 };
62 static struct pcmchan_caps sbpro_playcaps = {4000, 44100, sbpro_fmt, 0};
63 static struct pcmchan_caps sbpro_reccaps = {4000, 44100, sbpro_fmt, 0};
64
65 struct sb_info;
66
67 struct sb_chinfo {
68         struct sb_info *parent;
69         struct pcm_channel *channel;
70         struct snd_dbuf *buffer;
71         int dir;
72         u_int32_t fmt, spd, blksz;
73 };
74
75 struct sb_info {
76         device_t parent_dev;
77         struct resource *io_base;       /* I/O address for the board */
78         struct resource *irq;
79         struct resource *drq;
80         void *ih;
81         bus_dma_tag_t parent_dmat;
82
83         unsigned int bufsize;
84         int bd_id;
85         u_long bd_flags;       /* board-specific flags */
86         struct sb_chinfo pch, rch;
87 };
88
89 static int sb_rd(struct sb_info *sb, int reg);
90 static void sb_wr(struct sb_info *sb, int reg, u_int8_t val);
91 static int sb_dspready(struct sb_info *sb);
92 static int sb_cmd(struct sb_info *sb, u_char val);
93 static int sb_cmd1(struct sb_info *sb, u_char cmd, int val);
94 static int sb_cmd2(struct sb_info *sb, u_char cmd, int val);
95 static u_int sb_get_byte(struct sb_info *sb);
96 static void sb_setmixer(struct sb_info *sb, u_int port, u_int value);
97 static int sb_getmixer(struct sb_info *sb, u_int port);
98 static int sb_reset_dsp(struct sb_info *sb);
99
100 static void sb_intr(void *arg);
101 static int sb_speed(struct sb_chinfo *ch);
102 static int sb_start(struct sb_chinfo *ch);
103 static int sb_stop(struct sb_chinfo *ch);
104
105 /*
106  * Common code for the midi and pcm functions
107  *
108  * sb_cmd write a single byte to the CMD port.
109  * sb_cmd1 write a CMD + 1 byte arg
110  * sb_cmd2 write a CMD + 2 byte arg
111  * sb_get_byte returns a single byte from the DSP data port
112  */
113
114 static void
115 sb_lock(struct sb_info *sb) {
116
117         sbc_lock(device_get_softc(sb->parent_dev));
118 }
119
120 static void
121 sb_unlock(struct sb_info *sb) {
122
123         sbc_unlock(device_get_softc(sb->parent_dev));
124 }
125
126 static int
127 port_rd(struct resource *port, int off)
128 {
129         return bus_space_read_1(rman_get_bustag(port), rman_get_bushandle(port), off);
130 }
131
132 static void
133 port_wr(struct resource *port, int off, u_int8_t data)
134 {
135         bus_space_write_1(rman_get_bustag(port), rman_get_bushandle(port), off, data);
136 }
137
138 static int
139 sb_rd(struct sb_info *sb, int reg)
140 {
141         return port_rd(sb->io_base, reg);
142 }
143
144 static void
145 sb_wr(struct sb_info *sb, int reg, u_int8_t val)
146 {
147         port_wr(sb->io_base, reg, val);
148 }
149
150 static int
151 sb_dspready(struct sb_info *sb)
152 {
153         return ((sb_rd(sb, SBDSP_STATUS) & 0x80) == 0);
154 }
155
156 static int
157 sb_dspwr(struct sb_info *sb, u_char val)
158 {
159         int  i;
160
161         for (i = 0; i < 1000; i++) {
162                 if (sb_dspready(sb)) {
163                         sb_wr(sb, SBDSP_CMD, val);
164                         return 1;
165                 }
166                 if (i > 10) DELAY((i > 100)? 1000 : 10);
167         }
168         kprintf("sb_dspwr(0x%02x) timed out.\n", val);
169         return 0;
170 }
171
172 static int
173 sb_cmd(struct sb_info *sb, u_char val)
174 {
175 #if 0
176         kprintf("sb_cmd: %x\n", val);
177 #endif
178         return sb_dspwr(sb, val);
179 }
180
181 static int
182 sb_cmd1(struct sb_info *sb, u_char cmd, int val)
183 {
184 #if 0
185         kprintf("sb_cmd1: %x, %x\n", cmd, val);
186 #endif
187         if (sb_dspwr(sb, cmd)) {
188                 return sb_dspwr(sb, val & 0xff);
189         } else return 0;
190 }
191
192 static int
193 sb_cmd2(struct sb_info *sb, u_char cmd, int val)
194 {
195 #if 0
196         kprintf("sb_cmd2: %x, %x\n", cmd, val);
197 #endif
198         if (sb_dspwr(sb, cmd)) {
199                 return sb_dspwr(sb, val & 0xff) &&
200                        sb_dspwr(sb, (val >> 8) & 0xff);
201         } else return 0;
202 }
203
204 /*
205  * in the SB, there is a set of indirect "mixer" registers with
206  * address at offset 4, data at offset 5
207  *
208  * we don't need to interlock these, the mixer lock will suffice.
209  */
210 static void
211 sb_setmixer(struct sb_info *sb, u_int port, u_int value)
212 {
213         sb_wr(sb, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */
214         DELAY(10);
215         sb_wr(sb, SB_MIX_DATA, (u_char) (value & 0xff));
216         DELAY(10);
217 }
218
219 static int
220 sb_getmixer(struct sb_info *sb, u_int port)
221 {
222         int val;
223
224         sb_wr(sb, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */
225         DELAY(10);
226         val = sb_rd(sb, SB_MIX_DATA);
227         DELAY(10);
228
229         return val;
230 }
231
232 static u_int
233 sb_get_byte(struct sb_info *sb)
234 {
235         int i;
236
237         for (i = 1000; i > 0; i--) {
238                 if (sb_rd(sb, DSP_DATA_AVAIL) & 0x80)
239                         return sb_rd(sb, DSP_READ);
240                 else
241                         DELAY(20);
242         }
243         return 0xffff;
244 }
245
246 static int
247 sb_reset_dsp(struct sb_info *sb)
248 {
249         sb_wr(sb, SBDSP_RST, 3);
250         DELAY(100);
251         sb_wr(sb, SBDSP_RST, 0);
252         if (sb_get_byte(sb) != 0xAA) {
253                 DEB(kprintf("sb_reset_dsp 0x%lx failed\n",
254                            rman_get_start(sb->io_base)));
255                 return ENXIO;   /* Sorry */
256         }
257         return 0;
258 }
259
260 static void
261 sb_release_resources(struct sb_info *sb, device_t dev)
262 {
263         if (sb->irq) {
264                 if (sb->ih)
265                         bus_teardown_intr(dev, sb->irq, sb->ih);
266                 bus_release_resource(dev, SYS_RES_IRQ, 0, sb->irq);
267                 sb->irq = 0;
268         }
269         if (sb->drq) {
270                 isa_dma_release(rman_get_start(sb->drq));
271                 bus_release_resource(dev, SYS_RES_DRQ, 0, sb->drq);
272                 sb->drq = 0;
273         }
274         if (sb->io_base) {
275                 bus_release_resource(dev, SYS_RES_IOPORT, 0, sb->io_base);
276                 sb->io_base = 0;
277         }
278         if (sb->parent_dmat) {
279                 bus_dma_tag_destroy(sb->parent_dmat);
280                 sb->parent_dmat = 0;
281         }
282         kfree(sb, M_DEVBUF);
283 }
284
285 static int
286 sb_alloc_resources(struct sb_info *sb, device_t dev)
287 {
288         int rid;
289
290         rid = 0;
291         if (!sb->io_base)
292                 sb->io_base = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
293                         &rid, RF_ACTIVE);
294         rid = 0;
295         if (!sb->irq)
296                 sb->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
297                         &rid, RF_ACTIVE);
298         rid = 0;
299         if (!sb->drq)
300                 sb->drq = bus_alloc_resource_any(dev, SYS_RES_DRQ,
301                         &rid, RF_ACTIVE);
302
303         if (sb->io_base && sb->drq && sb->irq) {
304                 isa_dma_acquire(rman_get_start(sb->drq));
305                 isa_dmainit(rman_get_start(sb->drq), sb->bufsize);
306
307                 return 0;
308         } else return ENXIO;
309 }
310
311 /************************************************************/
312
313 static int
314 sbpromix_init(struct snd_mixer *m)
315 {
316         struct sb_info *sb = mix_getdevinfo(m);
317
318         mix_setdevs(m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE |
319                        SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_VOLUME);
320
321         mix_setrecdevs(m, SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD);
322
323         sb_setmixer(sb, 0, 1); /* reset mixer */
324
325         return 0;
326 }
327
328 static int
329 sbpromix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
330 {
331         struct sb_info *sb = mix_getdevinfo(m);
332         int reg, max;
333         u_char val;
334
335         max = 7;
336         switch (dev) {
337         case SOUND_MIXER_PCM:
338                 reg = 0x04;
339                 break;
340
341         case SOUND_MIXER_MIC:
342                 reg = 0x0a;
343                 max = 3;
344                 break;
345
346         case SOUND_MIXER_VOLUME:
347                 reg = 0x22;
348                 break;
349
350         case SOUND_MIXER_SYNTH:
351                 reg = 0x26;
352                 break;
353
354         case SOUND_MIXER_CD:
355                 reg = 0x28;
356                 break;
357
358         case SOUND_MIXER_LINE:
359                 reg = 0x2e;
360                 break;
361
362         default:
363                 return -1;
364         }
365
366         left = (left * max) / 100;
367         right = (dev == SOUND_MIXER_MIC)? left : ((right * max) / 100);
368
369         val = (dev == SOUND_MIXER_MIC)? (left << 1) : (left << 5 | right << 1);
370         sb_setmixer(sb, reg, val);
371
372         left = (left * 100) / max;
373         right = (right * 100) / max;
374
375         return left | (right << 8);
376 }
377
378 static int
379 sbpromix_setrecsrc(struct snd_mixer *m, u_int32_t src)
380 {
381         struct sb_info *sb = mix_getdevinfo(m);
382         u_char recdev;
383
384         if      (src == SOUND_MASK_LINE)
385                 recdev = 0x06;
386         else if (src == SOUND_MASK_CD)
387                 recdev = 0x02;
388         else { /* default: mic */
389                 src = SOUND_MASK_MIC;
390                 recdev = 0;
391         }
392         sb_setmixer(sb, RECORD_SRC, recdev | (sb_getmixer(sb, RECORD_SRC) & ~0x07));
393
394         return src;
395 }
396
397 static kobj_method_t sbpromix_mixer_methods[] = {
398         KOBJMETHOD(mixer_init,          sbpromix_init),
399         KOBJMETHOD(mixer_set,           sbpromix_set),
400         KOBJMETHOD(mixer_setrecsrc,     sbpromix_setrecsrc),
401         { 0, 0 }
402 };
403 MIXER_DECLARE(sbpromix_mixer);
404
405 /************************************************************/
406
407 static int
408 sbmix_init(struct snd_mixer *m)
409 {
410         struct sb_info *sb = mix_getdevinfo(m);
411
412         mix_setdevs(m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_CD | SOUND_MASK_VOLUME);
413
414         mix_setrecdevs(m, 0);
415
416         sb_setmixer(sb, 0, 1); /* reset mixer */
417
418         return 0;
419 }
420
421 static int
422 sbmix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
423 {
424         struct sb_info *sb = mix_getdevinfo(m);
425         int reg, max;
426
427         max = 7;
428         switch (dev) {
429         case SOUND_MIXER_VOLUME:
430                 reg = 0x2;
431                 break;
432
433         case SOUND_MIXER_SYNTH:
434                 reg = 0x6;
435                 break;
436
437         case SOUND_MIXER_CD:
438                 reg = 0x8;
439                 break;
440
441         case SOUND_MIXER_PCM:
442                 reg = 0x0a;
443                 max = 3;
444                 break;
445
446         default:
447                 return -1;
448         }
449
450         left = (left * max) / 100;
451
452         sb_setmixer(sb, reg, left << 1);
453
454         left = (left * 100) / max;
455
456         return left | (left << 8);
457 }
458
459 static int
460 sbmix_setrecsrc(struct snd_mixer *m, u_int32_t src)
461 {
462         return 0;
463 }
464
465 static kobj_method_t sbmix_mixer_methods[] = {
466         KOBJMETHOD(mixer_init,          sbmix_init),
467         KOBJMETHOD(mixer_set,           sbmix_set),
468         KOBJMETHOD(mixer_setrecsrc,     sbmix_setrecsrc),
469         { 0, 0 }
470 };
471 MIXER_DECLARE(sbmix_mixer);
472
473 /************************************************************/
474
475 static void
476 sb_intr(void *arg)
477 {
478         struct sb_info *sb = (struct sb_info *)arg;
479
480         sb_lock(sb);
481         if (sndbuf_runsz(sb->pch.buffer) > 0) {
482                 sb_unlock(sb);
483                 chn_intr(sb->pch.channel);
484                 sb_lock(sb);
485         }
486
487         if (sndbuf_runsz(sb->rch.buffer) > 0) {
488                 sb_unlock(sb);
489                 chn_intr(sb->rch.channel);
490                 sb_lock(sb);
491         }
492
493         sb_rd(sb, DSP_DATA_AVAIL); /* int ack */
494         sb_unlock(sb);
495 }
496
497 static int
498 sb_speed(struct sb_chinfo *ch)
499 {
500         struct sb_info *sb = ch->parent;
501         int play = (ch->dir == PCMDIR_PLAY)? 1 : 0;
502         int stereo = (ch->fmt & AFMT_STEREO)? 1 : 0;
503         int speed, tmp, thresh, max;
504         u_char tconst;
505
506         if (sb->bd_id >= 0x300) {
507                 thresh = stereo? 11025 : 23000;
508                 max = stereo? 22050 : 44100;
509         } else if (sb->bd_id > 0x200) {
510                 thresh = play? 23000 : 13000;
511                 max = play? 44100 : 15000;
512         } else {
513                 thresh = 999999;
514                 max = play? 23000 : 13000;
515         }
516
517         speed = ch->spd;
518         if (speed > max)
519                 speed = max;
520
521         sb_lock(sb);
522         sb->bd_flags &= ~BD_F_HISPEED;
523         if (speed > thresh)
524                 sb->bd_flags |= BD_F_HISPEED;
525
526         tmp = 65536 - (256000000 / (speed << stereo));
527         tconst = tmp >> 8;
528
529         sb_cmd1(sb, 0x40, tconst); /* set time constant */
530
531         speed = (256000000 / (65536 - tmp)) >> stereo;
532
533         ch->spd = speed;
534         sb_unlock(sb);
535         return speed;
536 }
537
538 static int
539 sb_start(struct sb_chinfo *ch)
540 {
541         struct sb_info *sb = ch->parent;
542         int play = (ch->dir == PCMDIR_PLAY)? 1 : 0;
543         int stereo = (ch->fmt & AFMT_STEREO)? 1 : 0;
544         int l = ch->blksz;
545         u_char i;
546
547         l--;
548
549         sb_lock(sb);
550         if (play)
551                 sb_cmd(sb, DSP_CMD_SPKON);
552
553         if (sb->bd_flags & BD_F_HISPEED)
554                 i = play? 0x90 : 0x98;
555         else
556                 i = play? 0x1c : 0x2c;
557
558         sb_setmixer(sb, 0x0e, stereo? 2 : 0);
559         sb_cmd2(sb, 0x48, l);
560         sb_cmd(sb, i);
561
562         sb->bd_flags |= BD_F_DMARUN;
563         sb_unlock(sb);
564         return 0;
565 }
566
567 static int
568 sb_stop(struct sb_chinfo *ch)
569 {
570         struct sb_info *sb = ch->parent;
571         int play = (ch->dir == PCMDIR_PLAY)? 1 : 0;
572
573         sb_lock(sb);
574         if (sb->bd_flags & BD_F_HISPEED)
575                 sb_reset_dsp(sb);
576         else {
577 #if 0
578                 /*
579                  * NOTE: DSP_CMD_DMAEXIT_8 does not work with old
580                  * soundblaster.
581                  */
582                 sb_cmd(sb, DSP_CMD_DMAEXIT_8);
583 #endif
584                 sb_reset_dsp(sb);
585         }
586
587         if (play)
588                 sb_cmd(sb, DSP_CMD_SPKOFF); /* speaker off */
589         sb_unlock(sb);
590         sb->bd_flags &= ~BD_F_DMARUN;
591         return 0;
592 }
593
594 /* channel interface */
595 static void *
596 sbchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
597 {
598         struct sb_info *sb = devinfo;
599         struct sb_chinfo *ch = (dir == PCMDIR_PLAY)? &sb->pch : &sb->rch;
600
601         ch->parent = sb;
602         ch->channel = c;
603         ch->dir = dir;
604         ch->buffer = b;
605         if (sndbuf_alloc(ch->buffer, sb->parent_dmat, sb->bufsize) != 0)
606                 return NULL;
607         sndbuf_dmasetup(ch->buffer, sb->drq);
608         return ch;
609 }
610
611 static int
612 sbchan_setformat(kobj_t obj, void *data, u_int32_t format)
613 {
614         struct sb_chinfo *ch = data;
615
616         ch->fmt = format;
617         return 0;
618 }
619
620 static int
621 sbchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
622 {
623         struct sb_chinfo *ch = data;
624
625         ch->spd = speed;
626         return sb_speed(ch);
627 }
628
629 static int
630 sbchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
631 {
632         struct sb_chinfo *ch = data;
633
634         ch->blksz = blocksize;
635         return ch->blksz;
636 }
637
638 static int
639 sbchan_trigger(kobj_t obj, void *data, int go)
640 {
641         struct sb_chinfo *ch = data;
642
643         if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
644                 return 0;
645
646         sndbuf_dma(ch->buffer, go);
647         if (go == PCMTRIG_START)
648                 sb_start(ch);
649         else
650                 sb_stop(ch);
651         return 0;
652 }
653
654 static int
655 sbchan_getptr(kobj_t obj, void *data)
656 {
657         struct sb_chinfo *ch = data;
658
659         return sndbuf_dmaptr(ch->buffer);
660 }
661
662 static struct pcmchan_caps *
663 sbchan_getcaps(kobj_t obj, void *data)
664 {
665         struct sb_chinfo *ch = data;
666         int p = (ch->dir == PCMDIR_PLAY)? 1 : 0;
667
668         if (ch->parent->bd_id == 0x200)
669                 return p? &sb200_playcaps : &sb200_reccaps;
670         if (ch->parent->bd_id < 0x300)
671                 return p? &sb201_playcaps : &sb201_reccaps;
672         return p? &sbpro_playcaps : &sbpro_reccaps;
673 }
674
675 static kobj_method_t sbchan_methods[] = {
676         KOBJMETHOD(channel_init,                sbchan_init),
677         KOBJMETHOD(channel_setformat,           sbchan_setformat),
678         KOBJMETHOD(channel_setspeed,            sbchan_setspeed),
679         KOBJMETHOD(channel_setblocksize,        sbchan_setblocksize),
680         KOBJMETHOD(channel_trigger,             sbchan_trigger),
681         KOBJMETHOD(channel_getptr,              sbchan_getptr),
682         KOBJMETHOD(channel_getcaps,             sbchan_getcaps),
683         { 0, 0 }
684 };
685 CHANNEL_DECLARE(sbchan);
686
687 /************************************************************/
688
689 static int
690 sb_probe(device_t dev)
691 {
692         char buf[64];
693         uintptr_t func, ver, r, f;
694
695         /* The parent device has already been probed. */
696         r = BUS_READ_IVAR(device_get_parent(dev), dev, 0, &func);
697         if (func != SCF_PCM)
698                 return (ENXIO);
699
700         r = BUS_READ_IVAR(device_get_parent(dev), dev, 1, &ver);
701         f = (ver & 0xffff0000) >> 16;
702         ver &= 0x0000ffff;
703         if ((f & BD_F_ESS) || (ver >= 0x400))
704                 return (ENXIO);
705
706         ksnprintf(buf, sizeof buf, "SB DSP %d.%02d", (int) ver >> 8, (int) ver & 0xff);
707
708         device_set_desc_copy(dev, buf);
709
710         return 0;
711 }
712
713 static int
714 sb_attach(device_t dev)
715 {
716         struct sb_info *sb;
717         char status[SND_STATUSLEN];
718         uintptr_t ver;
719
720         sb = (struct sb_info *)kmalloc(sizeof *sb, M_DEVBUF, M_NOWAIT | M_ZERO);
721         if (!sb)
722                 return ENXIO;
723
724         sb->parent_dev = device_get_parent(dev);
725         BUS_READ_IVAR(device_get_parent(dev), dev, 1, &ver);
726         sb->bd_id = ver & 0x0000ffff;
727         sb->bd_flags = (ver & 0xffff0000) >> 16;
728         sb->bufsize = pcm_getbuffersize(dev, 4096, SB_DEFAULT_BUFSZ, 65536);
729
730         if (sb_alloc_resources(sb, dev))
731                 goto no;
732         if (sb_reset_dsp(sb))
733                 goto no;
734         if (mixer_init(dev, (sb->bd_id < 0x300)? &sbmix_mixer_class : &sbpromix_mixer_class, sb))
735                 goto no;
736         if (snd_setup_intr(dev, sb->irq, 0, sb_intr, sb, &sb->ih))
737                 goto no;
738
739         pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX);
740
741         if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
742                         /*lowaddr*/BUS_SPACE_MAXADDR_24BIT,
743                         /*highaddr*/BUS_SPACE_MAXADDR,
744                         /*filter*/NULL, /*filterarg*/NULL,
745                         /*maxsize*/sb->bufsize, /*nsegments*/1,
746                         /*maxsegz*/0x3ffff, /*flags*/0,
747                         &sb->parent_dmat) != 0) {
748                 device_printf(dev, "unable to create dma tag\n");
749                 goto no;
750         }
751
752         ksnprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld drq %ld bufsz %u %s",
753                 rman_get_start(sb->io_base), rman_get_start(sb->irq),
754                 rman_get_start(sb->drq), sb->bufsize, PCM_KLDSTRING(snd_sb8));
755
756         if (pcm_register(dev, sb, 1, 1))
757                 goto no;
758         pcm_addchan(dev, PCMDIR_REC, &sbchan_class, sb);
759         pcm_addchan(dev, PCMDIR_PLAY, &sbchan_class, sb);
760
761         pcm_setstatus(dev, status);
762
763         return 0;
764
765 no:
766         sb_release_resources(sb, dev);
767         return ENXIO;
768 }
769
770 static int
771 sb_detach(device_t dev)
772 {
773         int r;
774         struct sb_info *sb;
775
776         r = pcm_unregister(dev);
777         if (r)
778                 return r;
779
780         sb = pcm_getdevinfo(dev);
781         sb_release_resources(sb, dev);
782         return 0;
783 }
784
785 static device_method_t sb_methods[] = {
786         /* Device interface */
787         DEVMETHOD(device_probe,         sb_probe),
788         DEVMETHOD(device_attach,        sb_attach),
789         DEVMETHOD(device_detach,        sb_detach),
790
791         { 0, 0 }
792 };
793
794 static driver_t sb_driver = {
795         "pcm",
796         sb_methods,
797         PCM_SOFTC_SIZE,
798 };
799
800 DRIVER_MODULE(snd_sb8, sbc, sb_driver, pcm_devclass, 0, 0);
801 MODULE_DEPEND(snd_sb8, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
802 MODULE_DEPEND(snd_sb8, snd_sbc, 1, 1, 1);
803 MODULE_VERSION(snd_sb8, 1);
804
805
806
807