sys/arch/sparc/dev/audioamd.c

   1 /*      $NetBSD: audioamd.c,v 1.24 2009/09/17 12:38:11 tsutsui Exp $    */
   2 /*      NetBSD: am7930_sparc.c,v 1.44 1999/03/14 22:29:00 jonathan Exp  */
   3
   4 /*
   5  * Copyright (c) 1995 Rolf Grossmann
   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. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Rolf Grossmann.
  19  * 4. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __KERNEL_RCSID(0, "$NetBSD: audioamd.c,v 1.24 2009/09/17 12:38:11 tsutsui Exp $");
  36
  37 #include "audio.h"
  38 #if NAUDIO > 0
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/errno.h>
  43 #include <sys/device.h>
  44 #include <sys/bus.h>
  45 #include <sys/intr.h>
  46 #include <sys/mutex.h>
  47
  48 #include <machine/autoconf.h>
  49
  50 #include <sys/audioio.h>
  51 #include <dev/audio_if.h>
  52
  53 #include <dev/ic/am7930reg.h>
  54 #include <dev/ic/am7930var.h>
  55 #include <sparc/dev/audioamdvar.h>
  56
  57 #define AUDIO_ROM_NAME "audio"
  58
  59 #ifdef AUDIO_DEBUG
  60 #define DPRINTF(x)      if (am7930debug) printf x
  61 #define DPRINTFN(n,x)   if (am7930debug>(n)) printf x
  62 #else
  63 #define DPRINTF(x)
  64 #define DPRINTFN(n,x)
  65 #endif  /* AUDIO_DEBUG */
  66
  67
  68 /* interrupt interfaces */
  69 int     am7930hwintr(void *);
  70 struct auio *auiop;
  71 void    am7930swintr(void *);
  72
  73 /* from amd7930intr.s: */
  74 void    amd7930_trap(void);
  75
  76 /*
  77  * interrupt-handler status
  78  */
  79 struct am7930_intrhand {
  80         int     (*ih_fun)(void *);
  81         void    *ih_arg;
  82 };
  83
  84 struct audioamd_softc {
  85         struct am7930_softc sc_am7930;  /* glue to MI code */
  86
  87         bus_space_tag_t sc_bt;          /* bus cookie */
  88         bus_space_handle_t sc_bh;       /* device registers */
  89
  90         struct am7930_intrhand  sc_ih;  /* interrupt vector (hw or sw)  */
  91         void    (*sc_rintr)(void*);     /* input completion intr handler */
  92         void    *sc_rarg;               /* arg for sc_rintr() */
  93         void    (*sc_pintr)(void*);     /* output completion intr handler */
  94         void    *sc_parg;               /* arg for sc_pintr() */
  95
  96         /* sc_au is special in that the hardware interrupt handler uses it */
  97         struct  auio sc_au;             /* recv and xmit buffers, etc */
  98 #define sc_intrcnt      sc_au.au_intrcnt        /* statistics */
  99         void    *sc_sicookie;           /* softintr(9) cookie */
 100         kmutex_t        sc_lock;
 101 };
 102
 103 int     audioamd_mainbus_match(device_t, cfdata_t, void *);
 104 void    audioamd_mainbus_attach(device_t, device_t, void *);
 105 int     audioamd_obio_match(device_t, cfdata_t, void *);
 106 void    audioamd_obio_attach(device_t, device_t, void *);
 107 int     audioamd_sbus_match(device_t, cfdata_t, void *);
 108 void    audioamd_sbus_attach(device_t, device_t, void *);
 109 void    audioamd_attach(struct audioamd_softc *, int);
 110
 111 CFATTACH_DECL(audioamd_mainbus, sizeof(struct audioamd_softc),
 112     audioamd_mainbus_match, audioamd_mainbus_attach, NULL, NULL);
 113
 114 CFATTACH_DECL(audioamd_obio, sizeof(struct audioamd_softc),
 115     audioamd_obio_match, audioamd_obio_attach, NULL, NULL);
 116
 117 CFATTACH_DECL(audioamd_sbus, sizeof(struct audioamd_softc),
 118     audioamd_sbus_match, audioamd_sbus_attach, NULL, NULL);
 119
 120 /*
 121  * Define our interface into the am7930 MI driver.
 122  */
 123
 124 uint8_t audioamd_codec_iread(struct am7930_softc *, int);
 125 uint16_t        audioamd_codec_iread16(struct am7930_softc *, int);
 126 uint8_t audioamd_codec_dread(struct audioamd_softc *, int);
 127 void    audioamd_codec_iwrite(struct am7930_softc *, int, uint8_t);
 128 void    audioamd_codec_iwrite16(struct am7930_softc *, int, uint16_t);
 129 void    audioamd_codec_dwrite(struct audioamd_softc *, int, uint8_t);
 130 void    audioamd_onopen(struct am7930_softc *);
 131 void    audioamd_onclose(struct am7930_softc *);
 132
 133 struct am7930_glue audioamd_glue = {
 134         audioamd_codec_iread,
 135         audioamd_codec_iwrite,
 136         audioamd_codec_iread16,
 137         audioamd_codec_iwrite16,
 138         audioamd_onopen,
 139         audioamd_onclose,
 140         0,
 141         0,
 142         0,
 143 };
 144
 145 /*
 146  * Define our interface to the higher level audio driver.
 147  */
 148 int     audioamd_start_output(void *, void *, int, void (*)(void *), void *);
 149 int     audioamd_start_input(void *, void *, int, void (*)(void *), void *);
 150 int     audioamd_getdev(void *, struct audio_device *);
 151
 152 const struct audio_hw_if sa_hw_if = {
 153         am7930_open,
 154         am7930_close,
 155         0,
 156         am7930_query_encoding,
 157         am7930_set_params,
 158         am7930_round_blocksize,
 159         am7930_commit_settings,
 160         0,
 161         0,
 162         audioamd_start_output,          /* md */
 163         audioamd_start_input,           /* md */
 164         am7930_halt_output,
 165         am7930_halt_input,
 166         0,
 167         audioamd_getdev,
 168         0,
 169         am7930_set_port,
 170         am7930_get_port,
 171         am7930_query_devinfo,
 172         0,
 173         0,
 174         0,
 175         0,
 176         am7930_get_props,
 177         0,
 178         0,
 179         0,
 180 };
 181
 182 struct audio_device audioamd_device = {
 183         "am7930",
 184         "x",
 185         "audioamd"
 186 };
 187
 188
 189 int
 190 audioamd_mainbus_match(device_t parent, cfdata_t cf, void *aux)
 191 {
 192         struct mainbus_attach_args *ma;
 193
 194         ma = aux;
 195         if (CPU_ISSUN4)
 196                 return 0;
 197         return strcmp(AUDIO_ROM_NAME, ma->ma_name) == 0;
 198 }
 199
 200 int
 201 audioamd_obio_match(device_t parent, cfdata_t cf, void *aux)
 202 {
 203         union obio_attach_args *uoba;
 204
 205         uoba = aux;
 206         if (uoba->uoba_isobio4 != 0)
 207                 return 0;
 208
 209         return strcmp("audio", uoba->uoba_sbus.sa_name) == 0;
 210 }
 211
 212 int
 213 audioamd_sbus_match(device_t parent, cfdata_t cf, void *aux)
 214 {
 215         struct sbus_attach_args *sa;
 216
 217         sa = aux;
 218         return strcmp(AUDIO_ROM_NAME, sa->sa_name) == 0;
 219 }
 220
 221 void
 222 audioamd_mainbus_attach(device_t parent, device_t self, void *aux)
 223 {
 224         struct mainbus_attach_args *ma;
 225         struct audioamd_softc *sc;
 226         bus_space_handle_t bh;
 227
 228         ma = aux;
 229         sc = device_private(self);
 230         sc->sc_bt = ma->ma_bustag;
 231
 232         if (bus_space_map(
 233                         ma->ma_bustag,
 234                         ma->ma_paddr,
 235                         AM7930_DREG_SIZE,
 236                         BUS_SPACE_MAP_LINEAR,
 237                         &bh) != 0) {
 238                 printf("%s: cannot map registers\n", device_xname(self));
 239                 return;
 240         }
 241         sc->sc_bh = bh;
 242         audioamd_attach(sc, ma->ma_pri);
 243 }
 244
 245 void
 246 audioamd_obio_attach(device_t parent, device_t self, void *aux)
 247 {
 248         union obio_attach_args *uoba;
 249         struct sbus_attach_args *sa;
 250         struct audioamd_softc *sc;
 251         bus_space_handle_t bh;
 252
 253         uoba = aux;
 254         sa = &uoba->uoba_sbus;
 255         sc = device_private(self);
 256         sc->sc_bt = sa->sa_bustag;
 257
 258         if (sbus_bus_map(sa->sa_bustag,
 259                          sa->sa_slot, sa->sa_offset,
 260                          AM7930_DREG_SIZE,
 261                          0, &bh) != 0) {
 262                 printf("%s: cannot map registers\n", device_xname(self));
 263                 return;
 264         }
 265         sc->sc_bh = bh;
 266         audioamd_attach(sc, sa->sa_pri);
 267 }
 268
 269 void
 270 audioamd_sbus_attach(device_t parent, device_t self, void *aux)
 271 {
 272         struct sbus_attach_args *sa;
 273         struct audioamd_softc *sc;
 274         bus_space_handle_t bh;
 275
 276         sa = aux;
 277         sc = device_private(self);
 278         sc->sc_bt = sa->sa_bustag;
 279
 280         if (sbus_bus_map(sa->sa_bustag,
 281                          sa->sa_slot, sa->sa_offset,
 282                          AM7930_DREG_SIZE,
 283                          0, &bh) != 0) {
 284                 printf("%s: cannot map registers\n", device_xname(self));
 285                 return;
 286         }
 287         sc->sc_bh = bh;
 288         audioamd_attach(sc, sa->sa_pri);
 289 }
 290
 291 void
 292 audioamd_attach(struct audioamd_softc *sc, int pri)
 293 {
 294         device_t self;
 295
 296         /*
 297          * Set up glue for MI code early; we use some of it here.
 298          */
 299         self = &sc->sc_am7930.sc_dev;
 300         sc->sc_am7930.sc_glue = &audioamd_glue;
 301         mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_HIGH);
 302
 303         am7930_init(&sc->sc_am7930, AUDIOAMD_POLL_MODE);
 304
 305         auiop = &sc->sc_au;
 306
 307         /* Copy bus tag & handle for use by am7930_trap */
 308         sc->sc_au.au_bt = sc->sc_bt;
 309         sc->sc_au.au_bh = sc->sc_bh;
 310         (void)bus_intr_establish2(sc->sc_bt, pri, IPL_HIGH,
 311                                   am7930hwintr, sc,
 312 #ifdef notyet /* XXX amd7930intr.s needs to be fixed for MI softint(9) */
 313                                   amd7930_trap
 314 #else
 315                                   NULL
 316 #endif
 317                                   );
 318
 319         sc->sc_sicookie = softint_establish(SOFTINT_SERIAL, am7930swintr, sc);
 320         if (sc->sc_sicookie == NULL) {
 321                 printf("\n%s: cannot establish software interrupt\n",
 322                         device_xname(self));
 323                 return;
 324         }
 325
 326         printf(" softpri %d\n", IPL_SOFTAUDIO);
 327
 328
 329         evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
 330             device_xname(self), "intr");
 331
 332         audio_attach_mi(&sa_hw_if, sc, self);
 333 }
 334
 335
 336 void
 337 audioamd_onopen(struct am7930_softc *sc)
 338 {
 339         struct audioamd_softc *mdsc;
 340
 341         mdsc = (struct audioamd_softc *)sc;
 342
 343         /* reset pdma state */
 344         mutex_spin_enter(&mdsc->sc_lock);
 345         mdsc->sc_rintr = 0;
 346         mdsc->sc_rarg = 0;
 347         mdsc->sc_pintr = 0;
 348         mdsc->sc_parg = 0;
 349         mdsc->sc_au.au_rdata = 0;
 350         mdsc->sc_au.au_pdata = 0;
 351         mutex_spin_exit(&mdsc->sc_lock);
 352 }
 353
 354
 355 void
 356 audioamd_onclose(struct am7930_softc *sc)
 357 {
 358         /* On sparc, just do the chipset-level halt. */
 359         am7930_halt_input(sc);
 360         am7930_halt_output(sc);
 361 }
 362
 363 int
 364 audioamd_start_output(void *addr, void *p, int cc,
 365                       void (*intr)(void *), void *arg)
 366 {
 367         struct audioamd_softc *sc;
 368
 369         DPRINTFN(1, ("sa_start_output: cc=%d %p (%p)\n", cc, intr, arg));
 370         sc = addr;
 371
 372         mutex_spin_enter(&sc->sc_lock);
 373         audioamd_codec_iwrite(&sc->sc_am7930,
 374             AM7930_IREG_INIT, AM7930_INIT_PMS_ACTIVE);
 375         sc->sc_pintr = intr;
 376         sc->sc_parg = arg;
 377         sc->sc_au.au_pdata = p;
 378         sc->sc_au.au_pend = (char *)p + cc - 1;
 379         mutex_spin_exit(&sc->sc_lock);
 380
 381         DPRINTF(("sa_start_output: started intrs.\n"));
 382         return(0);
 383 }
 384
 385 int
 386 audioamd_start_input(void *addr, void *p, int cc,
 387                      void (*intr)(void *), void *arg)
 388 {
 389         struct audioamd_softc *sc;
 390
 391         DPRINTFN(1, ("sa_start_input: cc=%d %p (%p)\n", cc, intr, arg));
 392         sc = addr;
 393
 394         mutex_spin_enter(&sc->sc_lock);
 395         audioamd_codec_iwrite(&sc->sc_am7930,
 396             AM7930_IREG_INIT, AM7930_INIT_PMS_ACTIVE);
 397         sc->sc_rintr = intr;
 398         sc->sc_rarg = arg;
 399         sc->sc_au.au_rdata = p;
 400         sc->sc_au.au_rend = (char *)p + cc -1;
 401         mutex_spin_exit(&sc->sc_lock);
 402
 403         DPRINTF(("sa_start_input: started intrs.\n"));
 404
 405         return(0);
 406 }
 407
 408
 409 /*
 410  * Pseudo-DMA support: either C or locore assember.
 411  */
 412
 413 int
 414 am7930hwintr(void *v)
 415 {
 416         struct audioamd_softc *sc;
 417         struct auio *au;
 418         uint8_t *d, *e;
 419         int k;
 420
 421         sc = v;
 422         au = &sc->sc_au;
 423         mutex_spin_enter(&sc->sc_lock);
 424
 425         /* clear interrupt */
 426         k = audioamd_codec_dread(sc, AM7930_DREG_IR);
 427         if ((k & (AM7930_IR_DTTHRSH|AM7930_IR_DRTHRSH|AM7930_IR_DSRI|
 428                   AM7930_IR_DERI|AM7930_IR_BBUFF)) == 0) {
 429                 mutex_spin_exit(&sc->sc_lock);
 430                 return 0;
 431         }
 432
 433         /* receive incoming data */
 434         d = au->au_rdata;
 435         e = au->au_rend;
 436         if (d && d <= e) {
 437                 *d = audioamd_codec_dread(sc, AM7930_DREG_BBRB);
 438                 au->au_rdata++;
 439                 if (d == e) {
 440                         DPRINTFN(1, ("am7930hwintr: swintr(r) requested"));
 441                         softint_schedule(sc->sc_sicookie);
 442                 }
 443         }
 444
 445         /* send outgoing data */
 446         d = au->au_pdata;
 447         e = au->au_pend;
 448         if (d && d <= e) {
 449                 audioamd_codec_dwrite(sc, AM7930_DREG_BBTB, *d);
 450                 au->au_pdata++;
 451                 if (d == e) {
 452                         DPRINTFN(1, ("am7930hwintr: swintr(p) requested"));
 453                         softint_schedule(sc->sc_sicookie);
 454                 }
 455         }
 456
 457         au->au_intrcnt.ev_count++;
 458         mutex_spin_exit(&sc->sc_lock);
 459
 460         return 1;
 461 }
 462
 463 void
 464 am7930swintr(void *sc0)
 465 {
 466         struct audioamd_softc *sc;
 467         struct auio *au;
 468         bool pint;
 469
 470         sc = sc0;
 471         DPRINTFN(1, ("audiointr: sc=%p\n", sc););
 472
 473         au = &sc->sc_au;
 474         mutex_spin_enter(&sc->sc_lock);
 475         if (au->au_rdata > au->au_rend && sc->sc_rintr != NULL) {
 476                 mutex_spin_exit(&sc->sc_lock);
 477                 (*sc->sc_rintr)(sc->sc_rarg);
 478                 mutex_spin_enter(&sc->sc_lock);
 479         }
 480         pint = (au->au_pdata > au->au_pend && sc->sc_pintr != NULL);
 481         mutex_spin_exit(&sc->sc_lock);
 482         if (pint)
 483                 (*sc->sc_pintr)(sc->sc_parg);
 484 }
 485
 486
 487 /* indirect write */
 488 void
 489 audioamd_codec_iwrite(struct am7930_softc *sc, int reg, uint8_t val)
 490 {
 491         struct audioamd_softc *mdsc;
 492
 493         mdsc = (struct audioamd_softc *)sc;
 494         audioamd_codec_dwrite(mdsc, AM7930_DREG_CR, reg);
 495         audioamd_codec_dwrite(mdsc, AM7930_DREG_DR, val);
 496 }
 497
 498 void
 499 audioamd_codec_iwrite16(struct am7930_softc *sc, int reg, uint16_t val)
 500 {
 501         struct audioamd_softc *mdsc;
 502
 503         mdsc = (struct audioamd_softc *)sc;
 504         audioamd_codec_dwrite(mdsc, AM7930_DREG_CR, reg);
 505         audioamd_codec_dwrite(mdsc, AM7930_DREG_DR, val);
 506         audioamd_codec_dwrite(mdsc, AM7930_DREG_DR, val>>8);
 507 }
 508
 509
 510 /* indirect read */
 511 uint8_t
 512 audioamd_codec_iread(struct am7930_softc *sc, int reg)
 513 {
 514         struct audioamd_softc *mdsc;
 515
 516         mdsc = (struct audioamd_softc *)sc;
 517         audioamd_codec_dwrite(mdsc, AM7930_DREG_CR, reg);
 518         return (audioamd_codec_dread(mdsc, AM7930_DREG_DR));
 519 }
 520
 521 uint16_t
 522 audioamd_codec_iread16(struct am7930_softc *sc, int reg)
 523 {
 524         struct audioamd_softc *mdsc;
 525         uint8_t lo, hi;
 526
 527         mdsc = (struct audioamd_softc *)sc;
 528         audioamd_codec_dwrite(mdsc, AM7930_DREG_CR, reg);
 529         lo = audioamd_codec_dread(mdsc, AM7930_DREG_DR);
 530         hi = audioamd_codec_dread(mdsc, AM7930_DREG_DR);
 531         return (hi << 8) | lo;
 532 }
 533
 534 /* direct read */
 535 uint8_t
 536 audioamd_codec_dread(struct audioamd_softc *sc, int reg)
 537 {
 538
 539         return bus_space_read_1(sc->sc_bt, sc->sc_bh, reg);
 540 }
 541
 542 /* direct write */
 543 void
 544 audioamd_codec_dwrite(struct audioamd_softc *sc, int reg, uint8_t val)
 545 {
 546
 547         bus_space_write_1(sc->sc_bt, sc->sc_bh, reg, val);
 548 }
 549
 550 int
 551 audioamd_getdev(void *addr, struct audio_device *retp)
 552 {
 553
 554         *retp = audioamd_device;
 555         return 0;
 556 }
 557
 558 #endif /* NAUDIO > 0 */