drivers/sbus/audio/cs4231.c

   1 /* $Id: cs4231.c,v 1.1.1.1 2005/04/11 02:50:34 jack Exp $
   2  * drivers/sbus/audio/cs4231.c
   3  *
   4  * Copyright 1996, 1997, 1998, 1999 Derrick J Brashear (shadow@andrew.cmu.edu)
   5  * The 4231/ebus support was written by David Miller, who didn't bother
   6  * crediting himself here, so I will.
   7  *
   8  * Based on the AMD7930 driver:
   9  * Copyright 1996 Thomas K. Dyas (tdyas@noc.rutgers.edu)
  10  *
  11  * This is the lowlevel driver for the CS4231 audio chip found on some
  12  * sun4m and sun4u machines.
  13  *
  14  * This was culled from the Crystal docs on the 4231a, and the addendum they
  15  * faxed me on the 4231.
  16  * The APC DMA controller support unfortunately is not documented. Thanks, Sun.
  17  */
  18
  19 #include <linux/config.h>
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/sched.h>
  23 #include <linux/errno.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/slab.h>
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/soundcard.h>
  29 #include <linux/version.h>
  30 #include <linux/ioport.h>
  31 #include <asm/openprom.h>
  32 #include <asm/oplib.h>
  33 #include <asm/system.h>
  34 #include <asm/irq.h>
  35 #include <asm/io.h>
  36 #include <asm/pgtable.h>
  37 #include <asm/sbus.h>
  38 #if defined(CONFIG_PCI) && defined(CONFIG_SPARC64)
  39 #define EB4231_SUPPORT
  40 #include <asm/ebus.h>
  41 #include <asm/pbm.h>
  42 #endif
  43
  44 #include <asm/audioio.h>
  45 #include "cs4231.h"
  46
  47 #undef __CS4231_DEBUG
  48 #undef __CS4231_TRACE
  49 #define __CS4231_ERROR
  50 #ifdef __CS4231_ERROR
  51 #define eprintk(x) printk x
  52 #else
  53 #define eprintk(x)
  54 #endif
  55 #ifdef __CS4231_TRACE
  56 #define tprintk(x) printk x
  57 #else
  58 #define tprintk(x)
  59 #endif
  60 #ifdef __CS4231_DEBUG
  61 #define dprintk(x) printk x
  62 #else
  63 #define dprintk(x)
  64 #endif
  65
  66 #define MAX_DRIVERS 1
  67 static struct sparcaudio_driver drivers[MAX_DRIVERS];
  68 static int num_drivers;
  69
  70 static int cs4231_record_gain(struct sparcaudio_driver *drv, int value,
  71                               unsigned char balance);
  72 static int cs4231_play_gain(struct sparcaudio_driver *drv, int value,
  73                             unsigned char balance);
  74 static void cs4231_ready(struct sparcaudio_driver *drv);
  75 static void cs4231_playintr(struct sparcaudio_driver *drv, int);
  76 static int cs4231_recintr(struct sparcaudio_driver *drv);
  77 static int cs4231_output_muted(struct sparcaudio_driver *drv, int value);
  78 static void cs4231_pollinput(struct sparcaudio_driver *drv);
  79 static int cs4231_length_to_samplecount(struct audio_prinfo *thisdir,
  80                                         unsigned int length);
  81 static void cs4231_getsamplecount(struct sparcaudio_driver *drv,
  82                                   unsigned int length, unsigned int value);
  83 #ifdef EB4231_SUPPORT
  84 static void eb4231_pollinput(struct sparcaudio_driver *drv);
  85 #endif
  86
  87 /* Serveral shorthands save typing... */
  88 #define CHIP_READY() \
  89 do { udelay(100); cs4231_ready(drv); udelay(1000); } while(0)
  90 #define WRITE_IAR(__VAL) \
  91         CS4231_WRITE8(cs4231_chip, cs4231_chip->regs + IAR, __VAL)
  92 #define WRITE_IDR(__VAL) \
  93         CS4231_WRITE8(cs4231_chip, cs4231_chip->regs + IDR, __VAL)
  94 #define READ_IAR() \
  95         CS4231_READ8(cs4231_chip, cs4231_chip->regs + IAR)
  96 #define READ_IDR() \
  97         CS4231_READ8(cs4231_chip, cs4231_chip->regs + IDR)
  98
  99 /* Enable cs4231 interrupts atomically. */
 100 static void cs4231_enable_interrupts(struct sparcaudio_driver *drv)
 101 {
 102         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 103         unsigned long flags;
 104
 105         tprintk(("enabling interrupts\n"));
 106         save_flags(flags);
 107         cli();
 108         if ((cs4231_chip->status & CS_STATUS_INTS_ON) == 0) {
 109                 WRITE_IAR(0xa);
 110                 WRITE_IDR(INTR_ON);
 111                 cs4231_chip->status |= CS_STATUS_INTS_ON;
 112         }
 113         restore_flags(flags);
 114 }
 115
 116 /* Disable cs4231 interrupts atomically. */
 117 static void cs4231_disable_interrupts(struct sparcaudio_driver *drv)
 118 {
 119         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 120         unsigned long flags;
 121
 122         tprintk(("disabling interrupts\n"));
 123         save_flags(flags);
 124         cli();
 125         if ((cs4231_chip->status & CS_STATUS_INTS_ON) != 0) {
 126                 WRITE_IAR(0xa);
 127                 WRITE_IDR(INTR_OFF);
 128                 cs4231_chip->status &= ~CS_STATUS_INTS_ON;
 129         }
 130         restore_flags(flags);
 131 }
 132
 133 static void cs4231_enable_play(struct sparcaudio_driver *drv)
 134 {
 135         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 136         unsigned long flags;
 137
 138         tprintk(("enabling play\n"));
 139         save_flags(flags);
 140         cli();
 141         WRITE_IAR(0x9);
 142         WRITE_IDR(READ_IDR() | PEN_ENABLE);
 143         restore_flags(flags);
 144 }
 145
 146 static void cs4231_disable_play(struct sparcaudio_driver *drv)
 147 {
 148         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 149         unsigned long flags;
 150
 151         tprintk(("disabling play\n"));
 152         save_flags(flags);
 153         cli();
 154         WRITE_IAR(0x9);
 155         WRITE_IDR(READ_IDR() & PEN_DISABLE);
 156         restore_flags(flags);
 157 }
 158
 159 static void cs4231_enable_rec(struct sparcaudio_driver *drv)
 160 {
 161         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 162         unsigned long flags;
 163
 164         tprintk(("enabling rec\n"));
 165         save_flags(flags);
 166         cli();
 167         WRITE_IAR(0x9);
 168         WRITE_IDR(READ_IDR() | CEN_ENABLE);
 169         restore_flags(flags);
 170 }
 171
 172 static void cs4231_disable_rec(struct sparcaudio_driver *drv)
 173 {
 174         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 175         unsigned long flags;
 176
 177         tprintk(("disabling rec\n"));
 178         save_flags(flags);
 179         cli();
 180         WRITE_IAR(0x9);
 181         WRITE_IDR(READ_IDR() & CEN_DISABLE);
 182         restore_flags(flags);
 183 }
 184
 185 static struct cs4231_rates {
 186         int speed, bits;
 187 } cs4231_rate_table[] = {
 188         { 5512, CS4231_DFR_5512 },
 189         { 6615, CS4231_DFR_6615 },
 190         { 8000, CS4231_DFR_8000 },
 191         { 9600, CS4231_DFR_9600 },
 192         { 11025, CS4231_DFR_11025 },
 193         { 16000, CS4231_DFR_16000 },
 194         { 18900, CS4231_DFR_18900 },
 195         { 22050, CS4231_DFR_22050 },
 196         { 27429, CS4231_DFR_27429 },
 197         { 32000, CS4231_DFR_32000 },
 198         { 33075, CS4231_DFR_33075 },
 199         { 37800, CS4231_DFR_37800 },
 200         { 44100, CS4231_DFR_44100 },
 201         { 48000, CS4231_DFR_48000 }
 202 };
 203
 204 #define NUM_RATES       (sizeof(cs4231_rate_table) / sizeof(struct cs4231_rates))
 205
 206 static int cs4231_rate_to_bits(struct sparcaudio_driver *drv, int *value)
 207 {
 208         struct cs4231_rates *p = &cs4231_rate_table[0];
 209         int i, wanted = *value;
 210
 211         /* We try to be nice and approximate what the user asks for. */
 212         if (wanted < 5512)
 213                 wanted = 5512;
 214         if (wanted > 48000)
 215                 wanted = 48000;
 216
 217         for (i = 0; i < NUM_RATES; i++, p++) {
 218                 /* Exact match? */
 219                 if (wanted == p->speed)
 220                         break;
 221
 222                 /* If we're inbetween two entries, and neither is exact,
 223                  * pick the closest one.
 224                  */
 225                 if (wanted == p[1].speed)
 226                         continue;
 227                 if (wanted > p->speed && wanted < p[1].speed) {
 228                         int diff1, diff2;
 229
 230                         diff1 = wanted - p->speed;
 231                         diff2 = p[1].speed - wanted;
 232                         if (diff2 < diff1)
 233                                 p++;
 234                         break;
 235                 }
 236         }
 237         *value = p->speed;
 238         return p->bits;
 239 }
 240
 241 static int cs4231_encoding_to_bits(struct sparcaudio_driver *drv, int value)
 242 {
 243         int set_bits;
 244
 245         switch (value) {
 246         case AUDIO_ENCODING_ULAW:
 247                 set_bits = CS4231_DFR_ULAW;
 248                 break;
 249         case AUDIO_ENCODING_ALAW:
 250                 set_bits = CS4231_DFR_ALAW;
 251                 break;
 252         case AUDIO_ENCODING_DVI:
 253                 set_bits = CS4231_DFR_ADPCM;
 254                 break;
 255         case AUDIO_ENCODING_LINEARLE:
 256                 set_bits = CS4231_DFR_LINEARLE;
 257                 break;
 258         case AUDIO_ENCODING_LINEAR:
 259                 set_bits = CS4231_DFR_LINEARBE;
 260                 break;
 261         case AUDIO_ENCODING_LINEAR8:
 262                 set_bits = CS4231_DFR_LINEAR8;
 263                 break;
 264         default:
 265                 set_bits = -EINVAL;
 266                 break;
 267         };
 268
 269         return set_bits;
 270 }
 271
 272 static int cs4231_set_output_encoding(struct sparcaudio_driver *drv, int value)
 273 {
 274         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 275         int tmp_bits, set_bits;
 276
 277         tprintk(("output encoding %d\n", value));
 278         if (value != 0) {
 279                 set_bits = cs4231_encoding_to_bits(drv, value);
 280                 if (set_bits >= 0) {
 281                         READ_IDR();
 282                         READ_IDR();
 283                         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x8);
 284                         tmp_bits = READ_IDR();
 285                         WRITE_IDR(CHANGE_ENCODING(tmp_bits, set_bits));
 286                         READ_IDR();
 287                         READ_IDR();
 288                         CHIP_READY();
 289                         cs4231_chip->perchip_info.play.encoding = value;
 290                         return 0;
 291                 }
 292         }
 293         dprintk(("output enc failed\n"));
 294         return -EINVAL;
 295 }
 296
 297 static int cs4231_get_output_encoding(struct sparcaudio_driver *drv)
 298 {
 299       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 300       return cs4231_chip->perchip_info.play.encoding;
 301 }
 302
 303 static int cs4231_set_input_encoding(struct sparcaudio_driver *drv, int value)
 304 {
 305         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 306         int tmp_bits, set_bits;
 307
 308         tprintk(("input encoding %d\n", value));
 309         if (value != 0) {
 310                 set_bits = cs4231_encoding_to_bits(drv, value);
 311                 if (set_bits >= 0) {
 312                         READ_IDR();
 313                         READ_IDR();
 314                         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x1c);
 315                         tmp_bits = READ_IDR();
 316                         WRITE_IDR(CHANGE_ENCODING(tmp_bits, set_bits));
 317                         READ_IDR();
 318                         READ_IDR();
 319                         CHIP_READY();
 320
 321                         cs4231_chip->perchip_info.record.encoding = value;
 322                         return 0;
 323                 }
 324         }
 325         dprintk(("input enc failed\n"));
 326         return -EINVAL;
 327 }
 328
 329 static int cs4231_get_input_encoding(struct sparcaudio_driver *drv)
 330 {
 331       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 332       return cs4231_chip->perchip_info.record.encoding;
 333 }
 334
 335 static int cs4231_set_output_rate(struct sparcaudio_driver *drv, int value)
 336 {
 337         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 338         int tmp_bits, set_bits;
 339
 340         tprintk(("output rate %d\n", value));
 341         if (value != 0) {
 342                 set_bits = cs4231_rate_to_bits(drv, &value);
 343                 if (set_bits >= 0) {
 344                         READ_IDR();
 345                         READ_IDR();
 346                         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x8);
 347                         tmp_bits = READ_IDR();
 348                         WRITE_IDR(CHANGE_DFR(tmp_bits, set_bits));
 349                         READ_IDR();
 350                         READ_IDR();
 351                         CHIP_READY();
 352
 353                         cs4231_chip->perchip_info.play.sample_rate = value;
 354                         tprintk(("tmp_bits[%02x] set_bits[%02x] CHANGE_DFR[%02x]\n",
 355                                  tmp_bits, set_bits, CHANGE_DFR(tmp_bits, set_bits)));
 356                         return 0;
 357                 }
 358         }
 359         dprintk(("output rate failed\n"));
 360         return -EINVAL;
 361 }
 362
 363 static int cs4231_get_output_rate(struct sparcaudio_driver *drv)
 364 {
 365       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 366       return cs4231_chip->perchip_info.play.sample_rate;
 367 }
 368
 369 static int cs4231_set_input_rate(struct sparcaudio_driver *drv, int value)
 370 {
 371         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 372         int tmp_bits, set_bits;
 373
 374         tprintk(("input rate %d\n", value));
 375         if (value != 0) {
 376                 set_bits = cs4231_rate_to_bits(drv, &value);
 377                 if (set_bits >= 0) {
 378                         READ_IDR();
 379                         READ_IDR();
 380                         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x1c);
 381                         tmp_bits = READ_IDR();
 382                         WRITE_IDR(CHANGE_DFR(tmp_bits, set_bits));
 383                         READ_IDR();
 384                         READ_IDR();
 385                         CHIP_READY();
 386
 387                         cs4231_chip->perchip_info.record.sample_rate = value;
 388                         return 0;
 389                 }
 390         }
 391         dprintk(("input rate failed\n"));
 392         return -EINVAL;
 393 }
 394
 395 static int cs4231_get_input_rate(struct sparcaudio_driver *drv)
 396 {
 397       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 398       return cs4231_chip->perchip_info.record.sample_rate;
 399 }
 400
 401 /* Generically we support 4 channels. This hardware does 2 */
 402 static int cs4231_set_input_channels(struct sparcaudio_driver *drv, int value)
 403 {
 404         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 405         int tmp_bits;
 406
 407         tprintk(("input channels %d\n", value));
 408         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x1c);
 409         tmp_bits = READ_IDR();
 410         switch (value) {
 411         case 1:
 412                 WRITE_IDR(CS4231_MONO_ON(tmp_bits));
 413                 break;
 414         case 2:
 415                 WRITE_IDR(CS4231_STEREO_ON(tmp_bits));
 416                 break;
 417         default:
 418                 dprintk(("input chan failed\n"));
 419                 return -EINVAL;
 420         };
 421         CHIP_READY();
 422
 423         cs4231_chip->perchip_info.record.channels = value;
 424         return 0;
 425 }
 426
 427 static int cs4231_get_input_channels(struct sparcaudio_driver *drv)
 428 {
 429       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 430       return cs4231_chip->perchip_info.record.channels;
 431 }
 432
 433 /* Generically we support 4 channels. This hardware does 2 */
 434 static int cs4231_set_output_channels(struct sparcaudio_driver *drv, int value)
 435 {
 436         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 437         int tmp_bits;
 438
 439         tprintk(("output channels %d\n", value));
 440         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x8);
 441         tmp_bits = READ_IDR();
 442         switch (value) {
 443         case 1:
 444                 WRITE_IDR(CS4231_MONO_ON(tmp_bits));
 445                 break;
 446         case 2:
 447                 WRITE_IDR(CS4231_STEREO_ON(tmp_bits));
 448                 break;
 449         default:
 450                 dprintk(("output chan failed\n"));
 451                 return -EINVAL;
 452         };
 453         CHIP_READY();
 454
 455         cs4231_chip->perchip_info.play.channels = value;
 456         return 0;
 457 }
 458
 459 static int cs4231_get_output_channels(struct sparcaudio_driver *drv)
 460 {
 461       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 462       return cs4231_chip->perchip_info.play.channels;
 463 }
 464
 465 static int cs4231_get_input_precision(struct sparcaudio_driver *drv)
 466 {
 467       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 468       return cs4231_chip->perchip_info.record.precision;
 469 }
 470
 471 static int cs4231_get_output_precision(struct sparcaudio_driver *drv)
 472 {
 473       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 474       return cs4231_chip->perchip_info.play.precision;
 475 }
 476
 477 static int cs4231_set_input_precision(struct sparcaudio_driver *drv, int val)
 478 {
 479       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 480
 481       cs4231_chip->perchip_info.record.precision = val;
 482
 483       return cs4231_chip->perchip_info.record.precision;
 484 }
 485
 486 static int cs4231_set_output_precision(struct sparcaudio_driver *drv, int val)
 487 {
 488       struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 489
 490       cs4231_chip->perchip_info.play.precision = val;
 491
 492       return cs4231_chip->perchip_info.play.precision;
 493 }
 494
 495 /* Wait until the auto calibration process has finished */
 496 static void cs4231_ready(struct sparcaudio_driver *drv)
 497 {
 498         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 499         unsigned int x;
 500
 501         WRITE_IAR(IAR_AUTOCAL_END);
 502         x = 0;
 503         do {
 504                 if (READ_IDR() != IAR_NOT_READY)
 505                         break;
 506                 x++;
 507         } while (x <= CS_TIMEOUT);
 508
 509         WRITE_IAR(0x0b);
 510         x = 0;
 511         do {
 512                 if (READ_IDR() != AUTOCAL_IN_PROGRESS)
 513                         break;
 514                 x++;
 515         } while (x <= CS_TIMEOUT);
 516 }
 517
 518 /* Set output mute */
 519 static int cs4231_output_muted(struct sparcaudio_driver *drv, int value)
 520 {
 521         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 522         tprintk(("in cs4231_output_muted: %d\n", value));
 523         if (!value) {
 524                 WRITE_IAR(0x7);
 525                 WRITE_IDR(READ_IDR() & OUTCR_UNMUTE);
 526                 WRITE_IAR(0x6);
 527                 WRITE_IDR(READ_IDR() & OUTCR_UNMUTE);
 528                 cs4231_chip->perchip_info.output_muted = 0;
 529         } else {
 530                 WRITE_IAR(0x7);
 531                 WRITE_IDR(READ_IDR() | OUTCR_MUTE);
 532                 WRITE_IAR(0x6);
 533                 WRITE_IDR(READ_IDR() | OUTCR_MUTE);
 534                 cs4231_chip->perchip_info.output_muted = 1;
 535         }
 536         return 0;
 537 }
 538
 539 static int cs4231_get_output_muted(struct sparcaudio_driver *drv)
 540 {
 541         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 542         return cs4231_chip->perchip_info.output_muted;
 543 }
 544
 545 static int cs4231_get_formats(struct sparcaudio_driver *drv)
 546 {
 547         return (AFMT_MU_LAW | AFMT_A_LAW |
 548                 AFMT_U8 | AFMT_IMA_ADPCM |
 549                 AFMT_S16_LE | AFMT_S16_BE);
 550 }
 551
 552 static int cs4231_get_output_ports(struct sparcaudio_driver *drv)
 553 {
 554         return (AUDIO_LINE_OUT | AUDIO_SPEAKER | AUDIO_HEADPHONE);
 555 }
 556
 557 static int cs4231_get_input_ports(struct sparcaudio_driver *drv)
 558 {
 559         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 560
 561         /* This apparently applies only to APC ultras, not ebus ultras */
 562         if (cs4231_chip->status & CS_STATUS_IS_ULTRA)
 563                 return (AUDIO_LINE_IN | AUDIO_MICROPHONE | AUDIO_ANALOG_LOOPBACK);
 564         else
 565                 return (AUDIO_INTERNAL_CD_IN | AUDIO_LINE_IN |
 566                         AUDIO_MICROPHONE | AUDIO_ANALOG_LOOPBACK);
 567 }
 568
 569 /* Set chip "output" port */
 570 static int cs4231_set_output_port(struct sparcaudio_driver *drv, int value)
 571 {
 572         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 573         int retval = 0;
 574
 575         tprintk(("output port: %d\n", value));
 576         /* Aaaaaah! It's all coming so fast! Turn it all off, then selectively
 577          * enable things.
 578          */
 579         WRITE_IAR(0x1a);
 580         WRITE_IDR(READ_IDR() | MONO_IOCR_MUTE);
 581         WRITE_IAR(0x0a);
 582         WRITE_IDR(READ_IDR() | PINCR_LINE_MUTE);
 583         WRITE_IDR(READ_IDR() | PINCR_HDPH_MUTE);
 584
 585         if (value & AUDIO_SPEAKER) {
 586                 WRITE_IAR(0x1a);
 587                 WRITE_IDR(READ_IDR() & ~MONO_IOCR_MUTE);
 588                 retval |= AUDIO_SPEAKER;
 589         }
 590
 591         if (value & AUDIO_HEADPHONE) {
 592                 WRITE_IAR(0x0a);
 593                 WRITE_IDR(READ_IDR() & ~PINCR_HDPH_MUTE);
 594                 retval |= AUDIO_HEADPHONE;
 595         }
 596
 597         if (value & AUDIO_LINE_OUT) {
 598                 WRITE_IAR(0x0a);
 599                 WRITE_IDR(READ_IDR() & ~PINCR_LINE_MUTE);
 600                 retval |= AUDIO_LINE_OUT;
 601         }
 602
 603         cs4231_chip->perchip_info.play.port = retval;
 604
 605         return (retval);
 606 }
 607
 608 static int cs4231_get_output_port(struct sparcaudio_driver *drv)
 609 {
 610         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 611         return cs4231_chip->perchip_info.play.port;
 612 }
 613
 614 /* Set chip "input" port */
 615 static int cs4231_set_input_port(struct sparcaudio_driver *drv, int value)
 616 {
 617         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 618         int retval = 0;
 619
 620         tprintk(("input port: %d\n", value));
 621
 622         /* You can have one and only one. This is probably wrong, but
 623          * appears to be how SunOS is doing it. Should be able to mix.
 624          * More work to be done. CD input mixable, analog loopback may be.
 625          */
 626
 627         /* Ultra systems do not support AUDIO_INTERNAL_CD_IN */
 628         /* This apparently applies only to APC ultras, not ebus ultras */
 629         if (!(cs4231_chip->status & CS_STATUS_IS_ULTRA)) {
 630                 if (value & AUDIO_INTERNAL_CD_IN) {
 631                         WRITE_IAR(0x1);
 632                         WRITE_IDR(CDROM_ENABLE(READ_IDR()));
 633                         WRITE_IAR(0x0);
 634                         WRITE_IDR(CDROM_ENABLE(READ_IDR()));
 635                         retval = AUDIO_INTERNAL_CD_IN;
 636                 }
 637         }
 638         if ((value & AUDIO_LINE_IN)) {
 639                 WRITE_IAR(0x1);
 640                 WRITE_IDR(LINE_ENABLE(READ_IDR()));
 641                 WRITE_IAR(0x0);
 642                 WRITE_IDR(LINE_ENABLE(READ_IDR()));
 643                 retval = AUDIO_LINE_IN;
 644         } else if (value & AUDIO_MICROPHONE) {
 645                 WRITE_IAR(0x1);
 646                 WRITE_IDR(MIC_ENABLE(READ_IDR()));
 647                 WRITE_IAR(0x0);
 648                 WRITE_IDR(MIC_ENABLE(READ_IDR()));
 649                 retval = AUDIO_MICROPHONE;
 650         } else if (value & AUDIO_ANALOG_LOOPBACK) {
 651                 WRITE_IAR(0x1);
 652                 WRITE_IDR(OUTPUTLOOP_ENABLE(READ_IDR()));
 653                 WRITE_IAR(0x0);
 654                 WRITE_IDR(OUTPUTLOOP_ENABLE(READ_IDR()));
 655                 retval = AUDIO_ANALOG_LOOPBACK;
 656         }
 657
 658         cs4231_chip->perchip_info.record.port = retval;
 659
 660         return retval;
 661 }
 662
 663 static int cs4231_get_input_port(struct sparcaudio_driver *drv)
 664 {
 665         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 666         return cs4231_chip->perchip_info.record.port;
 667 }
 668
 669 /* Set chip "monitor" gain */
 670 static int cs4231_set_monitor_volume(struct sparcaudio_driver *drv, int value)
 671 {
 672         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 673         int a = 0;
 674
 675         tprintk(("monitor gain: %d\n", value));
 676
 677         /* This interpolation really sucks. The question is, be compatible
 678          * with ScumOS/Sloaris or not?
 679          */
 680         a = CS4231_MON_MAX_ATEN - (value * (CS4231_MON_MAX_ATEN + 1) /
 681                                    (AUDIO_MAX_GAIN + 1));
 682
 683         WRITE_IAR(0x0d);
 684         if (a >= CS4231_MON_MAX_ATEN)
 685                 WRITE_IDR(LOOPB_OFF);
 686         else
 687                 WRITE_IDR((a << 2) | LOOPB_ON);
 688
 689         if (value == AUDIO_MAX_GAIN)
 690                 cs4231_chip->perchip_info.monitor_gain = AUDIO_MAX_GAIN;
 691         else
 692                 cs4231_chip->perchip_info.monitor_gain =
 693                         ((CS4231_MAX_DEV_ATEN - a) *
 694                          (AUDIO_MAX_GAIN + 1) /
 695                          (CS4231_MAX_DEV_ATEN + 1));
 696
 697         return 0;
 698 }
 699
 700 static int cs4231_get_monitor_volume(struct sparcaudio_driver *drv)
 701 {
 702         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 703
 704         return (int) cs4231_chip->perchip_info.monitor_gain;
 705 }
 706
 707 static int cs4231_get_output_error(struct sparcaudio_driver *drv)
 708 {
 709         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 710
 711         return (int) cs4231_chip->perchip_info.play.error;
 712 }
 713
 714 static int cs4231_get_input_error(struct sparcaudio_driver *drv)
 715 {
 716         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 717
 718         return (int) cs4231_chip->perchip_info.record.error;
 719 }
 720
 721 #ifdef EB4231_SUPPORT
 722 static int eb4231_get_output_samples(struct sparcaudio_driver *drv)
 723 {
 724         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 725         u32 dbcr = readl(cs4231_chip->eb2p + EBDMA_COUNT);
 726         int count =
 727                 cs4231_length_to_samplecount(&cs4231_chip->perchip_info.play, dbcr);
 728
 729         return (cs4231_chip->perchip_info.play.samples -
 730                 ((count > cs4231_chip->perchip_info.play.samples)
 731                  ? 0 : count));
 732 }
 733
 734 static int eb4231_get_input_samples(struct sparcaudio_driver *drv)
 735 {
 736         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 737         u32 dbcr = readl(cs4231_chip->eb2c + EBDMA_COUNT);
 738         int count =
 739                 cs4231_length_to_samplecount(&cs4231_chip->perchip_info.record, dbcr);
 740
 741         return (cs4231_chip->perchip_info.record.samples -
 742                 ((count > cs4231_chip->perchip_info.record.samples) ?
 743                 0 : count));
 744 }
 745 #endif
 746
 747 static int cs4231_get_output_samples(struct sparcaudio_driver *drv)
 748 {
 749         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 750         u32 dmapc = sbus_readl(cs4231_chip->regs + APCPC);
 751         int count =
 752           cs4231_length_to_samplecount(&cs4231_chip->perchip_info.play, dmapc);
 753
 754         return (cs4231_chip->perchip_info.play.samples -
 755                 ((count > cs4231_chip->perchip_info.play.samples)
 756                  ? 0 : count));
 757 }
 758
 759 static int cs4231_get_input_samples(struct sparcaudio_driver *drv)
 760 {
 761         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 762         u32 dmacc = sbus_readl(cs4231_chip->regs + APCCC);
 763         int count =
 764           cs4231_length_to_samplecount(&cs4231_chip->perchip_info.record, dmacc);
 765
 766         return (cs4231_chip->perchip_info.record.samples -
 767                 ((count > cs4231_chip->perchip_info.record.samples) ?
 768                 0 : count));
 769 }
 770
 771 static int cs4231_get_output_pause(struct sparcaudio_driver *drv)
 772 {
 773         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 774
 775         return (int) cs4231_chip->perchip_info.play.pause;
 776 }
 777
 778 static int cs4231_get_input_pause(struct sparcaudio_driver *drv)
 779 {
 780         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 781
 782         return (int) cs4231_chip->perchip_info.record.pause;
 783 }
 784
 785 /* But for play/record we have these cheesy jacket routines because of
 786  * how this crap gets set.
 787  */
 788 static int cs4231_set_input_volume(struct sparcaudio_driver *drv, int value)
 789 {
 790         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 791
 792         cs4231_record_gain(drv, value,
 793                            cs4231_chip->perchip_info.record.balance);
 794
 795         return 0;
 796 }
 797
 798 static int cs4231_get_input_volume(struct sparcaudio_driver *drv)
 799 {
 800         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 801
 802         return (int) cs4231_chip->perchip_info.record.gain;
 803 }
 804
 805 static int cs4231_set_output_volume(struct sparcaudio_driver *drv, int value)
 806 {
 807         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 808
 809         cs4231_play_gain(drv, value, cs4231_chip->perchip_info.play.balance);
 810
 811         return 0;
 812 }
 813
 814 static int cs4231_get_output_volume(struct sparcaudio_driver *drv)
 815 {
 816         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 817
 818         return cs4231_chip->perchip_info.play.gain;
 819 }
 820
 821 /* Likewise for balance */
 822 static int cs4231_set_input_balance(struct sparcaudio_driver *drv, int value)
 823 {
 824         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 825
 826         cs4231_chip->perchip_info.record.balance = value;
 827         cs4231_record_gain(drv, cs4231_chip->perchip_info.record.gain,
 828                            cs4231_chip->perchip_info.record.balance);
 829
 830         return 0;
 831 }
 832
 833 static int cs4231_get_input_balance(struct sparcaudio_driver *drv)
 834 {
 835         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 836
 837         return (int) cs4231_chip->perchip_info.record.balance;
 838 }
 839
 840 static int cs4231_set_output_balance(struct sparcaudio_driver *drv, int value)
 841 {
 842         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 843
 844         cs4231_chip->perchip_info.play.balance = value;
 845         cs4231_play_gain(drv, cs4231_chip->perchip_info.play.gain,
 846                          cs4231_chip->perchip_info.play.balance);
 847
 848         return 0;
 849 }
 850
 851 static int cs4231_get_output_balance(struct sparcaudio_driver *drv)
 852 {
 853         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 854
 855         return (int) cs4231_chip->perchip_info.play.balance;
 856 }
 857
 858 /* Set chip record gain */
 859 static int cs4231_record_gain(struct sparcaudio_driver *drv, int value,
 860                               unsigned char balance)
 861 {
 862         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 863         int tmp = 0, r, l, r_adj, l_adj;
 864         unsigned char old_gain;
 865
 866         r = l = value;
 867
 868         if (balance < AUDIO_MID_BALANCE) {
 869                 r = (int) (value -
 870                            ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT));
 871
 872                 if (r < 0)
 873                         r = 0;
 874         } else if (balance > AUDIO_MID_BALANCE) {
 875                 l = (int) (value -
 876                            ((balance - AUDIO_MID_BALANCE) << AUDIO_BALANCE_SHIFT));
 877
 878                 if (l < 0)
 879                         l = 0;
 880         }
 881
 882         l_adj = l * (CS4231_MAX_GAIN + 1) / (AUDIO_MAX_GAIN + 1);
 883         r_adj = r * (CS4231_MAX_GAIN + 1) / (AUDIO_MAX_GAIN + 1);
 884
 885         WRITE_IAR(0x0);
 886         old_gain = READ_IDR();
 887         WRITE_IDR(RECGAIN_SET(old_gain, l_adj));
 888         WRITE_IAR(0x1);
 889         old_gain = READ_IDR();
 890         WRITE_IDR(RECGAIN_SET(old_gain, r_adj));
 891
 892         if (l == value) {
 893                 (l == 0) ? (tmp = 0) : (tmp = ((l_adj + 1) * AUDIO_MAX_GAIN) /
 894                                         (CS4231_MAX_GAIN + 1));
 895         } else if (r == value) {
 896                 (r == 0) ? (tmp = 0) : (tmp = ((r_adj + 1) * AUDIO_MAX_GAIN) /
 897                                         (CS4231_MAX_GAIN + 1));
 898         }
 899         cs4231_chip->perchip_info.record.gain = tmp;
 900         return 0;
 901 }
 902
 903 /* Set chip play gain */
 904 static int cs4231_play_gain(struct sparcaudio_driver *drv, int value,
 905                             unsigned char balance)
 906 {
 907         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 908         int tmp = 0, r, l, r_adj, l_adj;
 909         unsigned char old_gain;
 910
 911         tprintk(("in play_gain: %d %c\n", value, balance));
 912         r = l = value;
 913         if (balance < AUDIO_MID_BALANCE) {
 914                 r = (int) (value -
 915                            ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT));
 916
 917                 if (r < 0)
 918                         r = 0;
 919         } else if (balance > AUDIO_MID_BALANCE) {
 920                 l = (int) (value -
 921                            ((balance - AUDIO_MID_BALANCE) << AUDIO_BALANCE_SHIFT));
 922
 923                 if (l < 0)
 924                         l = 0;
 925         }
 926
 927         (l == 0) ? (l_adj = CS4231_MAX_DEV_ATEN) : (l_adj = CS4231_MAX_ATEN -
 928                                                     (l * (CS4231_MAX_ATEN + 1) /
 929                                                      (AUDIO_MAX_GAIN + 1)));
 930         (r == 0) ? (r_adj = CS4231_MAX_DEV_ATEN) : (r_adj = CS4231_MAX_ATEN -
 931                                                     (r * (CS4231_MAX_ATEN + 1) /
 932                                                      (AUDIO_MAX_GAIN + 1)));
 933
 934         WRITE_IAR(0x6);
 935         old_gain = READ_IDR();
 936         WRITE_IDR(GAIN_SET(old_gain, l_adj));
 937         WRITE_IAR(0x7);
 938         old_gain = READ_IDR();
 939         WRITE_IDR(GAIN_SET(old_gain, r_adj));
 940
 941         if ((value == 0) || (value == AUDIO_MAX_GAIN)) {
 942                 tmp = value;
 943         } else {
 944                 if (value == l) {
 945                         tmp = ((CS4231_MAX_ATEN - l_adj) * (AUDIO_MAX_GAIN + 1) /
 946                                (CS4231_MAX_ATEN + 1));
 947                 } else if (value == r) {
 948                         tmp = ((CS4231_MAX_ATEN - r_adj) * (AUDIO_MAX_GAIN + 1) /
 949                                (CS4231_MAX_ATEN + 1));
 950                 }
 951         }
 952         cs4231_chip->perchip_info.play.gain = tmp;
 953
 954         return 0;
 955 }
 956
 957 /* Reset the audio chip to a sane state. */
 958 static void cs4231_chip_reset(struct sparcaudio_driver *drv)
 959 {
 960         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
 961         unsigned char vers;
 962
 963         tprintk(("in cs4231_chip_reset\n"));
 964
 965         if (cs4231_chip->status & CS_STATUS_IS_EBUS) {
 966 #ifdef EB4231_SUPPORT
 967                 writel(EBUS_DCSR_RESET, cs4231_chip->eb2p + EBDMA_CSR);
 968                 writel(EBUS_DCSR_RESET, cs4231_chip->eb2c + EBDMA_CSR);
 969                 writel(EBUS_DCSR_BURST_SZ_16, cs4231_chip->eb2p + EBDMA_CSR);
 970                 writel(EBUS_DCSR_BURST_SZ_16, cs4231_chip->eb2c + EBDMA_CSR);
 971 #endif
 972         } else {
 973                 u32 tmp;
 974
 975                 sbus_writel(APC_CHIP_RESET, cs4231_chip->regs + APCCSR);
 976                 sbus_writel(0x00, cs4231_chip->regs + APCCSR);
 977                 tmp = sbus_readl(cs4231_chip->regs + APCCSR);
 978                 tmp |= APC_CDC_RESET;
 979                 sbus_writel(tmp, cs4231_chip->regs + APCCSR);
 980
 981                 udelay(20);
 982
 983                 tmp = sbus_readl(cs4231_chip->regs + APCCSR);
 984                 tmp &= ~(APC_CDC_RESET);
 985                 sbus_writel(tmp, cs4231_chip->regs + APCCSR);
 986         }
 987
 988         WRITE_IAR(READ_IAR() | IAR_AUTOCAL_BEGIN);
 989         CHIP_READY();
 990
 991         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x0c);
 992         WRITE_IDR(MISC_IR_MODE2);
 993
 994         /* This is the equivalent of DEFAULT_DATA_FMAT */
 995         cs4231_set_input_encoding(drv, AUDIO_ENCODING_ULAW);
 996         cs4231_set_input_rate(drv, CS4231_RATE);
 997         cs4231_set_input_channels(drv, CS4231_CHANNELS);
 998         cs4231_set_input_precision(drv, CS4231_PRECISION);
 999
1000         cs4231_set_output_encoding(drv, AUDIO_ENCODING_ULAW);
1001         cs4231_set_output_rate(drv, CS4231_RATE);
1002         cs4231_set_output_channels(drv, CS4231_CHANNELS);
1003         cs4231_set_output_precision(drv, CS4231_PRECISION);
1004
1005         WRITE_IAR(0x19);
1006
1007         /* see what we can turn on */
1008         vers = READ_IDR();
1009         if (vers & CS4231A) {
1010                 tprintk(("This is a CS4231A\n"));
1011                 cs4231_chip->status |= CS_STATUS_REV_A;
1012         } else {
1013                 cs4231_chip->status &= ~CS_STATUS_REV_A;
1014         }
1015
1016         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x10);
1017         WRITE_IDR(OLB_ENABLE);
1018
1019         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x11);
1020         if (cs4231_chip->status & CS_STATUS_REV_A)
1021                 WRITE_IDR(HPF_ON | XTALE_ON);
1022         else
1023                 WRITE_IDR(HPF_ON);
1024
1025         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x1a);
1026         WRITE_IDR(0x00);
1027
1028         /* Now set things up for defaults */
1029         cs4231_set_input_balance(drv, AUDIO_MID_BALANCE);
1030         cs4231_set_output_balance(drv, AUDIO_MID_BALANCE);
1031
1032         cs4231_set_input_volume(drv, CS4231_DEFAULT_RECGAIN);
1033         cs4231_set_output_volume(drv, CS4231_DEFAULT_PLAYGAIN);
1034
1035         cs4231_set_input_port(drv, AUDIO_MICROPHONE);
1036         cs4231_set_output_port(drv, AUDIO_SPEAKER);
1037
1038         cs4231_set_monitor_volume(drv, LOOPB_OFF);
1039
1040         WRITE_IAR(IAR_AUTOCAL_END);
1041
1042         cs4231_ready(drv);
1043
1044         WRITE_IAR(IAR_AUTOCAL_BEGIN | 0x09);
1045         WRITE_IDR(READ_IDR() & ACAL_DISABLE);
1046         WRITE_IAR(IAR_AUTOCAL_END);
1047
1048         cs4231_ready(drv);
1049
1050         cs4231_output_muted(drv, 0);
1051
1052         cs4231_chip->recording_count = 0;
1053         cs4231_chip->input_next_dma_handle = 0;
1054         cs4231_chip->input_dma_handle = 0;
1055         cs4231_chip->input_next_dma_size = 0;
1056         cs4231_chip->input_dma_size = 0;
1057
1058         cs4231_chip->playing_count = 0;
1059         cs4231_chip->output_next_dma_handle = 0;
1060         cs4231_chip->output_dma_handle = 0;
1061         cs4231_chip->output_next_dma_size = 0;
1062         cs4231_chip->output_dma_size = 0;
1063 }
1064
1065 static int
1066 cs4231_length_to_samplecount(struct audio_prinfo *thisdir, unsigned int length)
1067 {
1068         unsigned int count;
1069
1070         if (thisdir->channels == 2)
1071                 count = (length / 2);
1072         else
1073                 count = length;
1074
1075         if (thisdir->encoding == AUDIO_ENCODING_LINEAR)
1076                 count = (count / 2);
1077         else if (thisdir->encoding == AUDIO_ENCODING_DVI)
1078                 count = (count / 4);
1079
1080         return count;
1081 }
1082
1083 #ifdef EB4231_SUPPORT
1084 static void eb4231_getsamplecount(struct sparcaudio_driver *drv,
1085                                   unsigned int length,
1086                                   unsigned int direction)
1087 {
1088         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1089         struct audio_prinfo *thisdir;
1090         unsigned int count, curcount, nextcount, dbcr;
1091
1092         if(direction == 1) {
1093                 thisdir = &cs4231_chip->perchip_info.record;
1094                 dbcr = readl(cs4231_chip->eb2c + EBDMA_COUNT);
1095                 nextcount = cs4231_chip->input_next_dma_size;
1096         } else {
1097                 thisdir = &cs4231_chip->perchip_info.play;
1098                 dbcr = readl(cs4231_chip->eb2p + EBDMA_COUNT);
1099                 nextcount = cs4231_chip->output_next_dma_size;
1100         }
1101         curcount = cs4231_length_to_samplecount(thisdir, dbcr);
1102         count = thisdir->samples;
1103         length = cs4231_length_to_samplecount(thisdir, length);
1104         /* normalize for where we are. */
1105         thisdir->samples = ((count - nextcount) + (length - curcount));
1106 }
1107 #endif
1108
1109 static void cs4231_getsamplecount(struct sparcaudio_driver *drv,
1110                                   unsigned int length,
1111                                   unsigned int direction)
1112 {
1113         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1114         struct audio_prinfo *thisdir;
1115         unsigned int count, nextcount, curcount;
1116         u32 tmp;
1117
1118         if (direction == 1) {
1119                 /* record */
1120                 thisdir = &cs4231_chip->perchip_info.record;
1121                 tmp = sbus_readl(cs4231_chip->regs + APCCC);
1122                 curcount = cs4231_length_to_samplecount(thisdir, tmp);
1123                 tmp = sbus_readl(cs4231_chip->regs + APCCNC);
1124                 nextcount = cs4231_length_to_samplecount(thisdir, tmp);
1125         } else {
1126                 /* play */
1127                 thisdir = &cs4231_chip->perchip_info.play;
1128                 tmp = sbus_readl(cs4231_chip->regs + APCPC);
1129                 curcount = cs4231_length_to_samplecount(thisdir, tmp);
1130                 tmp = sbus_readl(cs4231_chip->regs + APCPNC);
1131                 nextcount = cs4231_length_to_samplecount(thisdir, tmp);
1132         }
1133         count = thisdir->samples;
1134         length = cs4231_length_to_samplecount(thisdir, length);
1135
1136         /* normalize for where we are. */
1137         thisdir->samples = ((count - nextcount) + (length - curcount));
1138 }
1139
1140 static int cs4231_open(struct inode * inode, struct file * file, struct sparcaudio_driver *drv)
1141 {
1142         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1143
1144         /* Set the default audio parameters if not already in use. */
1145         if (file->f_mode & FMODE_WRITE) {
1146                 if (!(drv->flags & SDF_OPEN_WRITE) &&
1147                     (cs4231_chip->perchip_info.play.active == 0)) {
1148                         cs4231_chip->perchip_info.play.open = 1;
1149                         cs4231_chip->perchip_info.play.samples =
1150                                 cs4231_chip->perchip_info.play.error = 0;
1151                 }
1152         }
1153
1154         if (file->f_mode & FMODE_READ) {
1155                 if (!(drv->flags & SDF_OPEN_READ) &&
1156                     (cs4231_chip->perchip_info.record.active == 0)) {
1157                         cs4231_chip->perchip_info.record.open = 1;
1158                         cs4231_chip->perchip_info.record.samples =
1159                                 cs4231_chip->perchip_info.record.error = 0;
1160                 }
1161         }
1162
1163         cs4231_ready(drv);
1164         CHIP_READY();
1165
1166         MOD_INC_USE_COUNT;
1167
1168         return 0;
1169 }
1170
1171 static void cs4231_release(struct inode * inode, struct file * file, struct sparcaudio_driver *drv)
1172 {
1173         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *)drv->private;
1174         void (*dma_unmap_single)(struct sbus_dev *, dma_addr_t, size_t, int) = sbus_unmap_single;
1175
1176 #ifdef EB4231_SUPPORT
1177         if (cs4231_chip->status & CS_STATUS_IS_EBUS)
1178                 dma_unmap_single = (void (*)(struct sbus_dev *, dma_addr_t, size_t, int)) pci_unmap_single;
1179 #endif
1180         /* zero out any info about what data we have as well */
1181         if (file->f_mode & FMODE_READ) {
1182                 /* stop capture here or midlevel? */
1183                 cs4231_chip->perchip_info.record.open = 0;
1184                 if (cs4231_chip->input_dma_handle) {
1185                         dma_unmap_single(drv->dev,
1186                                          cs4231_chip->input_dma_handle,
1187                                          cs4231_chip->input_dma_size,
1188                                          SBUS_DMA_FROMDEVICE);
1189                         cs4231_chip->input_dma_handle = 0;
1190                         cs4231_chip->input_dma_size = 0;
1191                 }
1192                 if (cs4231_chip->input_next_dma_handle) {
1193                         dma_unmap_single(drv->dev,
1194                                          cs4231_chip->input_next_dma_handle,
1195                                          cs4231_chip->input_next_dma_size,
1196                                          SBUS_DMA_FROMDEVICE);
1197                         cs4231_chip->input_next_dma_handle = 0;
1198                         cs4231_chip->input_next_dma_size = 0;
1199                 }
1200         }
1201
1202         if (file->f_mode & FMODE_WRITE) {
1203                 cs4231_chip->perchip_info.play.active =
1204                         cs4231_chip->perchip_info.play.open = 0;
1205                 if (cs4231_chip->output_dma_handle) {
1206                         dma_unmap_single(drv->dev,
1207                                          cs4231_chip->output_dma_handle,
1208                                          cs4231_chip->output_dma_size,
1209                                          SBUS_DMA_TODEVICE);
1210                         cs4231_chip->output_dma_handle = 0;
1211                         cs4231_chip->output_dma_size = 0;
1212                 }
1213                 if (cs4231_chip->output_next_dma_handle) {
1214                         dma_unmap_single(drv->dev,
1215                                          cs4231_chip->output_next_dma_handle,
1216                                          cs4231_chip->output_next_dma_size,
1217                                          SBUS_DMA_TODEVICE);
1218                         cs4231_chip->output_next_dma_handle = 0;
1219                         cs4231_chip->output_next_dma_size = 0;
1220                 }
1221         }
1222
1223         if (!cs4231_chip->perchip_info.play.open &&
1224             !cs4231_chip->perchip_info.record.open &&
1225             (cs4231_chip->status & CS_STATUS_INIT_ON_CLOSE)) {
1226                 cs4231_chip_reset(drv);
1227                 cs4231_chip->status &= ~CS_STATUS_INIT_ON_CLOSE;
1228         }
1229
1230         MOD_DEC_USE_COUNT;
1231 }
1232
1233 static void cs4231_playintr(struct sparcaudio_driver *drv, int push)
1234 {
1235         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1236         int status = 0;
1237
1238         if (!push) {
1239                 if (!cs4231_chip->perchip_info.play.active) {
1240                         sbus_writel(cs4231_chip->output_next_dma_handle,
1241                                     cs4231_chip->regs + APCPNVA);
1242                         sbus_writel(cs4231_chip->output_next_dma_size,
1243                                     cs4231_chip->regs + APCPNC);
1244                 }
1245                 sparcaudio_output_done(drv, 0);
1246                 return;
1247         }
1248
1249         if (cs4231_chip->playlen == 0 && cs4231_chip->output_size > 0)
1250                 cs4231_chip->playlen = cs4231_chip->output_size;
1251
1252         if (cs4231_chip->output_dma_handle) {
1253                 sbus_unmap_single(drv->dev,
1254                                   cs4231_chip->output_dma_handle,
1255                                   cs4231_chip->output_dma_size,
1256                                   SBUS_DMA_TODEVICE);
1257                 cs4231_chip->output_dma_handle = 0;
1258                 cs4231_chip->output_dma_size = 0;
1259                 cs4231_chip->playing_count--;
1260                 status++;
1261         }
1262
1263         if (cs4231_chip->output_next_dma_handle) {
1264                 cs4231_chip->output_dma_handle = cs4231_chip->output_next_dma_handle;
1265                 cs4231_chip->output_dma_size = cs4231_chip->output_next_dma_size;
1266                 cs4231_chip->output_next_dma_size = 0;
1267                 cs4231_chip->output_next_dma_handle = 0;
1268         }
1269
1270         if ((cs4231_chip->output_ptr && cs4231_chip->output_size > 0) &&
1271             !(cs4231_chip->perchip_info.play.pause)) {
1272                 cs4231_chip->output_next_dma_handle =
1273                         sbus_map_single(drv->dev,
1274                                         (char *)cs4231_chip->output_ptr,
1275                                         cs4231_chip->output_size,
1276                                         SBUS_DMA_TODEVICE);
1277                 cs4231_chip->output_next_dma_size = cs4231_chip->output_size;
1278                 sbus_writel(cs4231_chip->output_next_dma_handle,
1279                             cs4231_chip->regs + APCPNVA);
1280                 sbus_writel(cs4231_chip->output_next_dma_size,
1281                             cs4231_chip->regs + APCPNC);
1282                 cs4231_chip->output_size = 0;
1283                 cs4231_chip->output_ptr = NULL;
1284                 cs4231_chip->playing_count++;
1285                 status += 2;
1286         } else {
1287                 sbus_writel(0, cs4231_chip->regs + APCPNVA);
1288                 sbus_writel(0, cs4231_chip->regs + APCPNC);
1289         }
1290
1291         sparcaudio_output_done(drv, status);
1292 }
1293
1294 #ifdef EB4231_SUPPORT
1295 static void eb4231_playintr(struct sparcaudio_driver *drv)
1296 {
1297         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1298         int status = 0;
1299
1300         if (cs4231_chip->playlen == 0 && cs4231_chip->output_size > 0)
1301                 cs4231_chip->playlen = cs4231_chip->output_size;
1302
1303         if (cs4231_chip->output_dma_handle) {
1304                 pci_unmap_single((struct pci_dev *)drv->dev,
1305                                  cs4231_chip->output_dma_handle,
1306                                  cs4231_chip->output_dma_size,
1307                                  PCI_DMA_TODEVICE);
1308                 cs4231_chip->output_dma_handle = 0;
1309                 cs4231_chip->output_dma_size = 0;
1310                 cs4231_chip->playing_count--;
1311                 status++;
1312         }
1313
1314         if(cs4231_chip->output_next_dma_handle) {
1315                 cs4231_chip->output_dma_handle = cs4231_chip->output_next_dma_handle;
1316                 cs4231_chip->output_dma_size = cs4231_chip->output_next_dma_size;
1317                 cs4231_chip->output_next_dma_handle = 0;
1318                 cs4231_chip->output_next_dma_size = 0;
1319         }
1320
1321         if ((cs4231_chip->output_ptr && cs4231_chip->output_size > 0) &&
1322             !(cs4231_chip->perchip_info.play.pause)) {
1323                 cs4231_chip->output_next_dma_handle =
1324                         pci_map_single((struct pci_dev *)drv->dev,
1325                                        (char *)cs4231_chip->output_ptr,
1326                                        cs4231_chip->output_size,
1327                                        PCI_DMA_TODEVICE);
1328                 cs4231_chip->output_next_dma_size = cs4231_chip->output_size;
1329
1330                 writel(cs4231_chip->output_next_dma_size,
1331                        cs4231_chip->eb2p + EBDMA_COUNT);
1332                 writel(cs4231_chip->output_next_dma_handle,
1333                        cs4231_chip->eb2p + EBDMA_ADDR);
1334                 cs4231_chip->output_size = 0;
1335                 cs4231_chip->output_ptr = NULL;
1336                 cs4231_chip->playing_count++;
1337                 status += 2;
1338         }
1339
1340         sparcaudio_output_done(drv, status);
1341 }
1342 #endif
1343
1344 static void cs4231_recclear(int fmt, char *dmabuf, int length)
1345 {
1346         switch (fmt) {
1347         case AUDIO_ENCODING_LINEAR:
1348                 memset(dmabuf, 0x00, length);
1349                 break;
1350         case AUDIO_ENCODING_ALAW:
1351                 memset(dmabuf, 0xd5, length);
1352                 break;
1353         case AUDIO_ENCODING_ULAW:
1354                 memset(dmabuf, 0xff, length);
1355                 break;
1356         }
1357 }
1358
1359 static int cs4231_recintr(struct sparcaudio_driver *drv)
1360 {
1361         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1362         int status = 0;
1363
1364         if (cs4231_chip->perchip_info.record.active == 0) {
1365                 dprintk(("going inactive\n"));
1366                 cs4231_pollinput(drv);
1367                 cs4231_disable_rec(drv);
1368         }
1369
1370         if (cs4231_chip->input_dma_handle) {
1371                 sbus_unmap_single(drv->dev,
1372                                   cs4231_chip->input_dma_handle,
1373                                   cs4231_chip->input_dma_size,
1374                                   SBUS_DMA_FROMDEVICE);
1375                 cs4231_chip->input_dma_handle = 0;
1376                 cs4231_chip->input_dma_size = 0;
1377                 cs4231_chip->recording_count--;
1378                 status++;
1379         }
1380
1381         if (cs4231_chip->input_next_dma_handle) {
1382                 cs4231_chip->input_dma_handle = cs4231_chip->input_next_dma_handle;
1383                 cs4231_chip->input_dma_size = cs4231_chip->input_next_dma_size;
1384                 cs4231_chip->input_next_dma_size = 0;
1385                 cs4231_chip->input_next_dma_handle = 0;
1386         }
1387
1388         if ((cs4231_chip->input_ptr && cs4231_chip->input_size > 0) &&
1389             !(cs4231_chip->perchip_info.record.pause)) {
1390                 cs4231_recclear(cs4231_chip->perchip_info.record.encoding,
1391                                 (char *)cs4231_chip->input_ptr,
1392                                 cs4231_chip->input_size);
1393                 cs4231_chip->input_next_dma_handle =
1394                         sbus_map_single(drv->dev,
1395                                         (char *)cs4231_chip->input_ptr,
1396                                         cs4231_chip->input_size,
1397                                         SBUS_DMA_FROMDEVICE);
1398                 cs4231_chip->input_next_dma_size = cs4231_chip->input_size;
1399                 sbus_writel(cs4231_chip->input_next_dma_handle,
1400                             cs4231_chip->regs + APCCNVA);
1401                 sbus_writel(cs4231_chip->input_next_dma_size,
1402                             cs4231_chip->regs + APCCNC);
1403                 cs4231_chip->input_size = 0;
1404                 cs4231_chip->input_ptr = NULL;
1405                 cs4231_chip->recording_count++;
1406                 status += 2;
1407         } else {
1408                 sbus_writel(0, cs4231_chip->regs + APCCNVA);
1409                 sbus_writel(0, cs4231_chip->regs + APCCNC);
1410         }
1411
1412         sparcaudio_input_done(drv, status);
1413         return 1;
1414 }
1415
1416 #ifdef EB4231_SUPPORT
1417 static int eb4231_recintr(struct sparcaudio_driver *drv)
1418 {
1419         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1420         int status = 0;
1421
1422         if (cs4231_chip->perchip_info.record.active == 0) {
1423                 dprintk(("going inactive\n"));
1424                 eb4231_pollinput(drv);
1425                 cs4231_disable_rec(drv);
1426         }
1427
1428         if (cs4231_chip->input_dma_handle) {
1429                 pci_unmap_single((struct pci_dev *)drv->dev,
1430                                  cs4231_chip->input_dma_handle,
1431                                  cs4231_chip->input_dma_size,
1432                                  PCI_DMA_FROMDEVICE);
1433                 cs4231_chip->input_dma_handle = 0;
1434                 cs4231_chip->input_dma_size = 0;
1435                 cs4231_chip->recording_count--;
1436                 status++;
1437         }
1438
1439         if (cs4231_chip->input_next_dma_handle) {
1440                 cs4231_chip->input_dma_handle = cs4231_chip->input_next_dma_handle;
1441                 cs4231_chip->input_dma_size = cs4231_chip->input_next_dma_size;
1442                 cs4231_chip->input_next_dma_size = 0;
1443                 cs4231_chip->input_next_dma_handle = 0;
1444         }
1445
1446         if ((cs4231_chip->input_ptr && cs4231_chip->input_size > 0) &&
1447             !(cs4231_chip->perchip_info.record.pause)) {
1448                 cs4231_recclear(cs4231_chip->perchip_info.record.encoding,
1449                                 (char *)cs4231_chip->input_ptr,
1450                                 cs4231_chip->input_size);
1451
1452                 cs4231_chip->input_next_dma_handle =
1453                         pci_map_single((struct pci_dev *)drv->dev,
1454                                        (char *)cs4231_chip->input_ptr,
1455                                        cs4231_chip->input_size,
1456                                        PCI_DMA_FROMDEVICE);
1457                 cs4231_chip->input_next_dma_size = cs4231_chip->input_size;
1458
1459                 writel(cs4231_chip->input_next_dma_size,
1460                        cs4231_chip->eb2c + EBDMA_COUNT);
1461                 writel(cs4231_chip->input_next_dma_handle,
1462                        cs4231_chip->eb2c + EBDMA_ADDR);
1463
1464                 cs4231_chip->input_size = 0;
1465                 cs4231_chip->input_ptr = NULL;
1466                 cs4231_chip->recording_count++;
1467                 status += 2;
1468         }
1469
1470         sparcaudio_input_done(drv, status);
1471         return 1;
1472 }
1473 #endif
1474
1475 #ifdef EB4231_SUPPORT
1476 static void eb4231_start_output(struct sparcaudio_driver *drv, __u8 * buffer,
1477                                 unsigned long count)
1478 {
1479         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1480         u32 dcsr;
1481
1482         cs4231_chip->output_ptr = buffer;
1483         cs4231_chip->output_size = count;
1484
1485         if (cs4231_chip->perchip_info.play.active ||
1486             (cs4231_chip->perchip_info.play.pause))
1487                 return;
1488
1489         cs4231_ready(drv);
1490
1491         cs4231_chip->perchip_info.play.active = 1;
1492         cs4231_chip->playing_count = 0;
1493
1494         dcsr = readl(cs4231_chip->eb2p + EBDMA_CSR);
1495         if (!(dcsr & EBUS_DCSR_EN_DMA)) {
1496                 writel(EBUS_DCSR_RESET, cs4231_chip->eb2p + EBDMA_CSR);
1497                 writel(EBUS_DCSR_BURST_SZ_16, cs4231_chip->eb2p + EBDMA_CSR);
1498
1499                 eb4231_playintr(drv);
1500
1501                 writel(EBUS_DCSR_BURST_SZ_16 |
1502                        (EBUS_DCSR_EN_DMA | EBUS_DCSR_INT_EN |
1503                         EBUS_DCSR_EN_CNT | EBUS_DCSR_EN_NEXT),
1504                        cs4231_chip->eb2p + EBDMA_CSR);
1505
1506                 cs4231_enable_play(drv);
1507
1508                 cs4231_ready(drv);
1509         } else {
1510                 eb4231_playintr(drv);
1511         }
1512 }
1513 #endif
1514
1515 static void cs4231_start_output(struct sparcaudio_driver *drv, __u8 * buffer,
1516                                 unsigned long count)
1517 {
1518         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1519         u32 csr;
1520
1521         tprintk(("in 4231 start output\n"));
1522         cs4231_chip->output_ptr = buffer;
1523         cs4231_chip->output_size = count;
1524
1525         if (cs4231_chip->perchip_info.play.active ||
1526             (cs4231_chip->perchip_info.play.pause))
1527                 return;
1528
1529         cs4231_ready(drv);
1530
1531         cs4231_chip->perchip_info.play.active = 1;
1532         cs4231_chip->playing_count = 0;
1533
1534         csr = sbus_readl(cs4231_chip->regs + APCCSR);
1535         if ((csr & APC_PPAUSE) || !(csr & APC_PDMA_READY)) {
1536                 u32 pnva;
1537
1538                 csr &= ~APC_XINT_PLAY;
1539                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
1540                 csr &= ~APC_PPAUSE;
1541                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
1542
1543                 pnva = sbus_readl(cs4231_chip->regs + APCPNVA);
1544                 cs4231_playintr(drv, (pnva == 0) ? 1 : 0);
1545
1546                 csr |= APC_PLAY_SETUP;
1547                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
1548                 cs4231_enable_play(drv);
1549
1550                 cs4231_ready(drv);
1551         }
1552 }
1553
1554 #ifdef EB4231_SUPPORT
1555 static void eb4231_stop_output(struct sparcaudio_driver *drv)
1556 {
1557         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1558         u32 dcsr;
1559
1560         dprintk(("eb4231_stop_output: dcsr 0x%x dacr 0x%x dbcr %d\n",
1561                  readl(cs4231_chip->eb2p + EBDMA_CSR),
1562                  readl(cs4231_chip->eb2p + EBDMA_ADDR),
1563                  readl(cs4231_chip->eb2p + EBDMA_COUNT)));
1564
1565         cs4231_chip->output_ptr = NULL;
1566         cs4231_chip->output_size = 0;
1567
1568         if (cs4231_chip->output_dma_handle) {
1569                 pci_unmap_single((struct pci_dev *)drv->dev,
1570                                  cs4231_chip->output_dma_handle,
1571                                  cs4231_chip->output_dma_size,
1572                                  PCI_DMA_TODEVICE);
1573                 cs4231_chip->output_dma_handle = 0;
1574                 cs4231_chip->output_dma_size = 0;
1575         }
1576
1577         if (cs4231_chip->output_next_dma_handle) {
1578                 pci_unmap_single((struct pci_dev *)drv->dev,
1579                                  cs4231_chip->output_next_dma_handle,
1580                                  cs4231_chip->output_next_dma_size,
1581                                  PCI_DMA_TODEVICE);
1582                 cs4231_chip->output_next_dma_handle = 0;
1583                 cs4231_chip->output_next_dma_size = 0;
1584         }
1585         dcsr = readl(cs4231_chip->eb2p + EBDMA_CSR);
1586         if(dcsr & EBUS_DCSR_EN_DMA)
1587                 writel(dcsr & ~EBUS_DCSR_EN_DMA,
1588                        cs4231_chip->eb2p + EBDMA_CSR);
1589
1590         /* Else subsequent speed setting changes are ignored by the chip. */
1591         cs4231_disable_play(drv);
1592 }
1593 #endif
1594
1595 static void cs4231_stop_output(struct sparcaudio_driver *drv)
1596 {
1597         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1598
1599         tprintk(("in cs4231_stop_output\n"));
1600         cs4231_chip->output_ptr = NULL;
1601         cs4231_chip->output_size = 0;
1602
1603         if (cs4231_chip->output_dma_handle) {
1604                 sbus_unmap_single(drv->dev,
1605                                   cs4231_chip->output_dma_handle,
1606                                   cs4231_chip->output_dma_size,
1607                                   SBUS_DMA_TODEVICE);
1608                 cs4231_chip->output_dma_handle = 0;
1609                 cs4231_chip->output_dma_size = 0;
1610         }
1611
1612         if (cs4231_chip->output_next_dma_handle) {
1613                 sbus_unmap_single(drv->dev,
1614                                   cs4231_chip->output_next_dma_handle,
1615                                   cs4231_chip->output_next_dma_size,
1616                                   SBUS_DMA_TODEVICE);
1617                 cs4231_chip->output_next_dma_handle = 0;
1618                 cs4231_chip->output_next_dma_size = 0;
1619         }
1620 #if 0 /* Not safe without shutting off the DMA controller as well. -DaveM */
1621         /* Else subsequent speed setting changes are ignored by the chip. */
1622         cs4231_disable_play(drv);
1623 #endif
1624 }
1625
1626 #ifdef EB4231_SUPPORT
1627 static void eb4231_pollinput(struct sparcaudio_driver *drv)
1628 {
1629         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1630         int x;
1631         u32 dcsr;
1632
1633         x = 0;
1634         do {
1635                 dcsr = readl(cs4231_chip->eb2c + EBDMA_CSR);
1636                 if (dcsr & EBUS_DCSR_TC)
1637                         break;
1638                 x++;
1639         } while (x <= CS_TIMEOUT);
1640
1641         writel(dcsr | EBUS_DCSR_TC,
1642                cs4231_chip->eb2c + EBDMA_CSR);
1643 }
1644 #endif
1645
1646 static void cs4231_pollinput(struct sparcaudio_driver *drv)
1647 {
1648         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1649         int x;
1650         u32 csr;
1651
1652         x = 0;
1653         do {
1654                 csr = sbus_readl(cs4231_chip->regs + APCCSR);
1655                 if (csr & APC_XINT_COVF)
1656                         break;
1657                 x++;
1658         } while (x <= CS_TIMEOUT);
1659
1660         sbus_writel(csr | APC_XINT_CEMP,
1661                     cs4231_chip->regs + APCCSR);
1662 }
1663
1664 static void cs4231_start_input(struct sparcaudio_driver *drv, __u8 * buffer,
1665                                unsigned long count)
1666 {
1667         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1668         u32 csr;
1669
1670         cs4231_chip->input_ptr = buffer;
1671         cs4231_chip->input_size = count;
1672
1673         if (cs4231_chip->perchip_info.record.active ||
1674             (cs4231_chip->perchip_info.record.pause))
1675                 return;
1676
1677         cs4231_ready(drv);
1678
1679         cs4231_chip->perchip_info.record.active = 1;
1680         cs4231_chip->recording_count = 0;
1681
1682         csr = sbus_readl(cs4231_chip->regs + APCCSR);
1683         if ((csr & APC_CPAUSE) || !(csr & APC_CDMA_READY)) {
1684                 csr &= ~APC_XINT_CAPT;
1685                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
1686                 csr &= ~APC_CPAUSE;
1687                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
1688
1689                 cs4231_recintr(drv);
1690
1691                 csr |= APC_CAPT_SETUP;
1692                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
1693
1694                 cs4231_enable_rec(drv);
1695                 cs4231_ready(drv);
1696         } else {
1697                 cs4231_recintr(drv);
1698         }
1699 }
1700
1701 static void cs4231_stop_input(struct sparcaudio_driver *drv)
1702 {
1703         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1704         u32 csr;
1705
1706         cs4231_chip->perchip_info.record.active = 0;
1707
1708         csr = sbus_readl(cs4231_chip->regs + APCCSR);
1709         csr |= APC_CPAUSE;
1710         sbus_writel(csr, cs4231_chip->regs + APCCSR);
1711
1712         cs4231_chip->input_ptr = NULL;
1713         cs4231_chip->input_size = 0;
1714
1715         if (cs4231_chip->input_dma_handle) {
1716                 sbus_unmap_single(drv->dev,
1717                                   cs4231_chip->input_dma_handle,
1718                                   cs4231_chip->input_dma_size,
1719                                   SBUS_DMA_FROMDEVICE);
1720                 cs4231_chip->input_dma_handle = 0;
1721                 cs4231_chip->input_dma_size = 0;
1722         }
1723
1724         if (cs4231_chip->input_next_dma_handle) {
1725                 sbus_unmap_single(drv->dev,
1726                                   cs4231_chip->input_next_dma_handle,
1727                                   cs4231_chip->input_next_dma_size,
1728                                   SBUS_DMA_FROMDEVICE);
1729                 cs4231_chip->input_next_dma_handle = 0;
1730                 cs4231_chip->input_next_dma_size = 0;
1731         }
1732
1733         cs4231_pollinput(drv);
1734 }
1735
1736 #ifdef EB4231_SUPPORT
1737 static void eb4231_start_input(struct sparcaudio_driver *drv, __u8 * buffer,
1738                                unsigned long count)
1739 {
1740         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1741         u32 dcsr;
1742
1743         cs4231_chip->input_ptr = buffer;
1744         cs4231_chip->input_size = count;
1745
1746         if (cs4231_chip->perchip_info.record.active ||
1747             (cs4231_chip->perchip_info.record.pause))
1748                 return;
1749
1750         cs4231_ready(drv);
1751         cs4231_chip->perchip_info.record.active = 1;
1752         cs4231_chip->recording_count = 0;
1753
1754         dcsr = readl(cs4231_chip->eb2c + EBDMA_CSR);
1755         if (!(dcsr & EBUS_DCSR_EN_DMA)) {
1756                 writel(EBUS_DCSR_RESET, cs4231_chip->eb2c + EBDMA_CSR);
1757                 writel(EBUS_DCSR_BURST_SZ_16, cs4231_chip->eb2c + EBDMA_CSR);
1758
1759                 eb4231_recintr(drv);
1760
1761                 writel(EBUS_DCSR_BURST_SZ_16 |
1762                        (EBUS_DCSR_EN_DMA | EBUS_DCSR_INT_EN |
1763                         EBUS_DCSR_EN_CNT | EBUS_DCSR_EN_NEXT),
1764                        cs4231_chip->eb2c + EBDMA_CSR);
1765
1766                 cs4231_enable_rec(drv);
1767                 cs4231_ready(drv);
1768         } else {
1769                 eb4231_recintr(drv);
1770         }
1771 }
1772
1773 static void eb4231_stop_input(struct sparcaudio_driver *drv)
1774 {
1775         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1776         u32 dcsr;
1777
1778         cs4231_chip->perchip_info.record.active = 0;
1779
1780         cs4231_chip->input_ptr = NULL;
1781         cs4231_chip->input_size = 0;
1782
1783         if (cs4231_chip->input_dma_handle) {
1784                 pci_unmap_single((struct pci_dev *)drv->dev,
1785                                  cs4231_chip->input_dma_handle,
1786                                  cs4231_chip->input_dma_size,
1787                                  PCI_DMA_FROMDEVICE);
1788                 cs4231_chip->input_dma_handle = 0;
1789                 cs4231_chip->input_dma_size = 0;
1790         }
1791
1792         if (cs4231_chip->input_next_dma_handle) {
1793                 pci_unmap_single((struct pci_dev *)drv->dev,
1794                                  cs4231_chip->input_next_dma_handle,
1795                                  cs4231_chip->input_next_dma_size,
1796                                  PCI_DMA_FROMDEVICE);
1797                 cs4231_chip->input_next_dma_handle = 0;
1798                 cs4231_chip->input_next_dma_size = 0;
1799         }
1800
1801         dcsr = readl(cs4231_chip->eb2c + EBDMA_CSR);
1802         if (dcsr & EBUS_DCSR_EN_DMA)
1803                 writel(dcsr & ~EBUS_DCSR_EN_DMA, cs4231_chip->eb2c + EBDMA_CSR);
1804
1805         cs4231_disable_rec(drv);
1806 }
1807 #endif
1808
1809 static int cs4231_set_output_pause(struct sparcaudio_driver *drv, int value)
1810 {
1811         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1812
1813         cs4231_chip->perchip_info.play.pause = value;
1814
1815         if (!value)
1816                 sparcaudio_output_done(drv, 0);
1817
1818         return value;
1819 }
1820
1821 static int cs4231_set_output_error(struct sparcaudio_driver *drv, int value)
1822 {
1823         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1824         int i;
1825
1826         i = cs4231_chip->perchip_info.play.error;
1827         cs4231_chip->perchip_info.play.error = value;
1828
1829         return i;
1830 }
1831
1832 static int cs4231_set_input_error(struct sparcaudio_driver *drv, int value)
1833 {
1834         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1835         int i;
1836
1837         i = cs4231_chip->perchip_info.record.error;
1838         cs4231_chip->perchip_info.record.error = value;
1839
1840         return i;
1841 }
1842
1843 static int cs4231_set_output_samples(struct sparcaudio_driver *drv, int value)
1844 {
1845         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *)drv->private;
1846         int i;
1847
1848         i = cs4231_chip->perchip_info.play.samples;
1849         cs4231_chip->perchip_info.play.samples = value;
1850
1851         return i;
1852 }
1853
1854 static int cs4231_set_input_samples(struct sparcaudio_driver *drv, int value)
1855 {
1856         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1857         int i;
1858
1859         i = cs4231_chip->perchip_info.record.samples;
1860         cs4231_chip->perchip_info.record.samples = value;
1861
1862         return i;
1863 }
1864
1865 static int cs4231_set_input_pause(struct sparcaudio_driver *drv, int value)
1866 {
1867         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1868
1869         cs4231_chip->perchip_info.record.pause = value;
1870
1871         if (value)
1872                 cs4231_stop_input(drv);
1873
1874         return value;
1875 }
1876
1877 static void cs4231_audio_getdev(struct sparcaudio_driver *drv,
1878                                  audio_device_t * audinfo)
1879 {
1880         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1881
1882         strncpy(audinfo->name, "SUNW,CS4231", sizeof(audinfo->name) - 1);
1883         /* versions */
1884         /* a: SPARCstation 4/5          b: Ultra 1/2 (electron)       */
1885         /* c: Ultra 1/2 PCI? (positron) d: ppc                        */
1886         /* e: x86                       f: Ultra Enterprise? (tazmo)  */
1887         /* g: Ultra 30? (quark)         h: Ultra 5/10? (darwin)       */
1888         /* apparently Ultra 1, Ultra 2 don't have internal CD input */
1889         if (cs4231_chip->status & CS_STATUS_IS_ULTRA)
1890                 strncpy(audinfo->version, "b", sizeof(audinfo->version) - 1);
1891         else
1892                 strncpy(audinfo->version, "a", sizeof(audinfo->version) - 1);
1893         strncpy(audinfo->config, "onboard1", sizeof(audinfo->config) - 1);
1894 }
1895
1896
1897 static int cs4231_audio_getdev_sunos(struct sparcaudio_driver *drv)
1898 {
1899         return AUDIO_DEV_CS4231;
1900 }
1901
1902 static void cs4231_loopback(struct sparcaudio_driver *drv, unsigned int value)
1903 {
1904         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1905
1906         WRITE_IAR(0x0d);
1907         WRITE_IDR(value ? LOOPB_ON : 0);
1908 }
1909
1910 static int cs4231_ioctl(struct inode * inode, struct file * file,
1911                         unsigned int cmd, unsigned long arg,
1912                         struct sparcaudio_driver *drv)
1913 {
1914         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1915         int retval = 0;
1916
1917         switch (cmd) {
1918         case AUDIO_DIAG_LOOPBACK:
1919                 cs4231_chip->status |= CS_STATUS_INIT_ON_CLOSE;
1920                 cs4231_loopback(drv, (unsigned int)arg);
1921                 break;
1922         default:
1923                 retval = -EINVAL;
1924         };
1925
1926         return retval;
1927 }
1928
1929 #ifdef EB4231_SUPPORT
1930 /* ebus audio capture interrupt handler. */
1931 void eb4231_cinterrupt(int irq, void *dev_id, struct pt_regs *regs)
1932 {
1933         struct sparcaudio_driver *drv = (struct sparcaudio_driver *) dev_id;
1934         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1935         u32 dummy;
1936
1937         /* Clear the interrupt. */
1938         dummy = readl(cs4231_chip->eb2c + EBDMA_CSR);
1939         writel(dummy, cs4231_chip->eb2c + EBDMA_CSR);
1940
1941         if ((dummy & EBUS_DCSR_TC) != 0
1942             /*&& (dummy & EBUS_DCSR_A_LOADED) != 0*/) {
1943                 cs4231_chip->perchip_info.record.samples +=
1944                     cs4231_length_to_samplecount(&(cs4231_chip->perchip_info.record),
1945                                                  cs4231_chip->reclen);
1946                 eb4231_recintr(drv);
1947         }
1948
1949         if ((dummy & EBUS_DCSR_A_LOADED) == 0) {
1950                 cs4231_chip->perchip_info.record.active = 0;
1951                 eb4231_recintr(drv);
1952                 eb4231_getsamplecount(drv, cs4231_chip->reclen, 1);
1953         }
1954 }
1955
1956 /* ebus audio play interrupt handler. */
1957 void eb4231_pinterrupt(int irq, void *dev_id, struct pt_regs *regs)
1958 {
1959         struct sparcaudio_driver *drv = (struct sparcaudio_driver *) dev_id;
1960         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1961         u32 dummy;
1962
1963         /* Clear the interrupt.  Bleh, when not using the next-address
1964          * feature, TC can only be cleared by a reset.
1965          */
1966         dummy = readl(cs4231_chip->eb2p + EBDMA_CSR);
1967         writel(dummy, cs4231_chip->eb2p + EBDMA_CSR);
1968
1969         /* If we get a terminal count and address loaded condition,
1970          * this means the DNAR was copied into DACR.
1971          */
1972         if((dummy & EBUS_DCSR_TC) != 0
1973            /*&& (dummy & EBUS_DCSR_A_LOADED) != 0*/) {
1974                 cs4231_chip->perchip_info.play.samples +=
1975                         cs4231_length_to_samplecount(&(cs4231_chip->perchip_info.play),
1976                                                      cs4231_chip->playlen);
1977                 eb4231_playintr(drv);
1978         }
1979
1980         if((dummy & EBUS_DCSR_A_LOADED) == 0) {
1981                 cs4231_chip->perchip_info.play.active = 0;
1982                 eb4231_playintr(drv);
1983                 eb4231_getsamplecount(drv, cs4231_chip->playlen, 0);
1984         }
1985 }
1986 #endif
1987
1988 /* Audio interrupt handler. */
1989 void cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1990 {
1991         struct sparcaudio_driver *drv = (struct sparcaudio_driver *) dev_id;
1992         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
1993         __u32 dummy;
1994
1995         dprintk(("in cs4231_interrupt\n"));
1996
1997         /* Clear the interrupt. */
1998         dummy = sbus_readl(cs4231_chip->regs + APCCSR);
1999         sbus_writel(dummy, cs4231_chip->regs + APCCSR);
2000
2001         /* now go through and figure out what gets to claim the interrupt
2002          * if anything since we may be doing shared interrupts
2003          */
2004         if (dummy & APC_PLAY_INT) {
2005                 if (dummy & APC_XINT_PNVA) {
2006                         cs4231_chip->perchip_info.play.samples +=
2007                          cs4231_length_to_samplecount(&(cs4231_chip->perchip_info.play),
2008                                                       cs4231_chip->playlen);
2009                         if (!(dummy & APC_XINT_EMPT))
2010                                 cs4231_playintr(drv, 1);
2011                 }
2012                 /* Any other conditions we need worry about? */
2013         }
2014
2015         if (dummy & APC_CAPT_INT) {
2016                 if (dummy & APC_XINT_CNVA) {
2017                   cs4231_chip->perchip_info.record.samples +=
2018                     cs4231_length_to_samplecount(&(cs4231_chip->perchip_info.record),
2019                                                  cs4231_chip->reclen);
2020                   cs4231_recintr(drv);
2021                 }
2022                 /* Any other conditions we need worry about? */
2023         }
2024
2025
2026         if (dummy & APC_XINT_CEMP) {
2027                 if (cs4231_chip->perchip_info.record.active == 0) {
2028                         /* Fix me */
2029                         cs4231_chip->perchip_info.record.active = 0;
2030                         cs4231_chip->perchip_info.record.error = 1;
2031                         cs4231_recintr(drv);
2032                 }
2033         }
2034
2035         if (dummy & APC_XINT_EMPT) {
2036                 if (!cs4231_chip->output_next_dma_handle) {
2037                         u32 csr = sbus_readl(cs4231_chip->regs + APCCSR);
2038
2039                         csr |= APC_PPAUSE;
2040                         sbus_writel(csr, cs4231_chip->regs + APCCSR);
2041                         cs4231_disable_play(drv);
2042                         cs4231_chip->perchip_info.play.error = 1;
2043                 }
2044                 cs4231_chip->perchip_info.play.active = 0;
2045                 cs4231_playintr(drv, 0);
2046
2047                 cs4231_getsamplecount(drv, cs4231_chip->playlen, 0);
2048         }
2049
2050         if (dummy & APC_GENL_INT) {
2051                 /* If we get here we must be sharing an interrupt, but I haven't code
2052                  * to handle this right now.
2053                  */
2054         }
2055 }
2056
2057 static struct sparcaudio_operations cs4231_ops = {
2058         cs4231_open,
2059         cs4231_release,
2060         cs4231_ioctl,
2061         cs4231_start_output,
2062         cs4231_stop_output,
2063         cs4231_start_input,
2064         cs4231_stop_input,
2065         cs4231_audio_getdev,
2066         cs4231_set_output_volume,
2067         cs4231_get_output_volume,
2068         cs4231_set_input_volume,
2069         cs4231_get_input_volume,
2070         cs4231_set_monitor_volume,
2071         cs4231_get_monitor_volume,
2072         cs4231_set_output_balance,
2073         cs4231_get_output_balance,
2074         cs4231_set_input_balance,
2075         cs4231_get_input_balance,
2076         cs4231_set_output_channels,
2077         cs4231_get_output_channels,
2078         cs4231_set_input_channels,
2079         cs4231_get_input_channels,
2080         cs4231_set_output_precision,
2081         cs4231_get_output_precision,
2082         cs4231_set_input_precision,
2083         cs4231_get_input_precision,
2084         cs4231_set_output_port,
2085         cs4231_get_output_port,
2086         cs4231_set_input_port,
2087         cs4231_get_input_port,
2088         cs4231_set_output_encoding,
2089         cs4231_get_output_encoding,
2090         cs4231_set_input_encoding,
2091         cs4231_get_input_encoding,
2092         cs4231_set_output_rate,
2093         cs4231_get_output_rate,
2094         cs4231_set_input_rate,
2095         cs4231_get_input_rate,
2096         cs4231_audio_getdev_sunos,
2097         cs4231_get_output_ports,
2098         cs4231_get_input_ports,
2099         cs4231_output_muted,
2100         cs4231_get_output_muted,
2101         cs4231_set_output_pause,
2102         cs4231_get_output_pause,
2103         cs4231_set_input_pause,
2104         cs4231_get_input_pause,
2105         cs4231_set_output_samples,
2106         cs4231_get_output_samples,
2107         cs4231_set_input_samples,
2108         cs4231_get_input_samples,
2109         cs4231_set_output_error,
2110         cs4231_get_output_error,
2111         cs4231_set_input_error,
2112         cs4231_get_input_error,
2113         cs4231_get_formats,
2114 };
2115
2116 #ifdef EB4231_SUPPORT
2117 static struct sparcaudio_operations eb4231_ops = {
2118         cs4231_open,
2119         cs4231_release,
2120         cs4231_ioctl,
2121         eb4231_start_output,
2122         eb4231_stop_output,
2123         eb4231_start_input,
2124         eb4231_stop_input,
2125         cs4231_audio_getdev,
2126         cs4231_set_output_volume,
2127         cs4231_get_output_volume,
2128         cs4231_set_input_volume,
2129         cs4231_get_input_volume,
2130         cs4231_set_monitor_volume,
2131         cs4231_get_monitor_volume,
2132         cs4231_set_output_balance,
2133         cs4231_get_output_balance,
2134         cs4231_set_input_balance,
2135         cs4231_get_input_balance,
2136         cs4231_set_output_channels,
2137         cs4231_get_output_channels,
2138         cs4231_set_input_channels,
2139         cs4231_get_input_channels,
2140         cs4231_set_output_precision,
2141         cs4231_get_output_precision,
2142         cs4231_set_input_precision,
2143         cs4231_get_input_precision,
2144         cs4231_set_output_port,
2145         cs4231_get_output_port,
2146         cs4231_set_input_port,
2147         cs4231_get_input_port,
2148         cs4231_set_output_encoding,
2149         cs4231_get_output_encoding,
2150         cs4231_set_input_encoding,
2151         cs4231_get_input_encoding,
2152         cs4231_set_output_rate,
2153         cs4231_get_output_rate,
2154         cs4231_set_input_rate,
2155         cs4231_get_input_rate,
2156         cs4231_audio_getdev_sunos,
2157         cs4231_get_output_ports,
2158         cs4231_get_input_ports,
2159         cs4231_output_muted,
2160         cs4231_get_output_muted,
2161         cs4231_set_output_pause,
2162         cs4231_get_output_pause,
2163         cs4231_set_input_pause,
2164         cs4231_get_input_pause,
2165         cs4231_set_output_samples,
2166         eb4231_get_output_samples,
2167         cs4231_set_input_samples,
2168         eb4231_get_input_samples,
2169         cs4231_set_output_error,
2170         cs4231_get_output_error,
2171         cs4231_set_input_error,
2172         cs4231_get_input_error,
2173         cs4231_get_formats,
2174 };
2175 #endif
2176
2177 /* Attach to an cs4231 chip given its PROM node. */
2178 static int cs4231_attach(struct sparcaudio_driver *drv,
2179                          struct sbus_dev *sdev)
2180 {
2181         struct cs4231_chip *cs4231_chip;
2182         int err;
2183
2184         /* Allocate our private information structure. */
2185         drv->private = kmalloc(sizeof(struct cs4231_chip), GFP_KERNEL);
2186         if (drv->private == NULL)
2187                 return -ENOMEM;
2188
2189         /* Point at the information structure and initialize it. */
2190         drv->ops = &cs4231_ops;
2191         cs4231_chip = (struct cs4231_chip *) drv->private;
2192         cs4231_chip->input_ptr = cs4231_chip->output_ptr = NULL;
2193         cs4231_chip->input_size = cs4231_chip->output_size = 0;
2194         cs4231_chip->status = 0;
2195
2196         drv->dev = sdev;
2197
2198         /* Map the registers into memory. */
2199         cs4231_chip->regs_size = sdev->reg_addrs[0].reg_size;
2200         cs4231_chip->regs = sbus_ioremap(&sdev->resource[0], 0,
2201                                          sdev->reg_addrs[0].reg_size,
2202                                          "cs4231");
2203
2204         if (!cs4231_chip->regs) {
2205                 printk(KERN_ERR "cs4231: could not remap registers\n");
2206                 kfree(drv->private);
2207                 return -EIO;
2208         }
2209
2210         /* Attach the interrupt handler to the audio interrupt. */
2211         cs4231_chip->irq = sdev->irqs[0];
2212         request_irq(cs4231_chip->irq, cs4231_interrupt, SA_SHIRQ, "cs4231", drv);
2213
2214         cs4231_chip->nirqs = 1;
2215         cs4231_enable_interrupts(drv);
2216
2217         /* Reset the audio chip. */
2218         cs4231_chip_reset(drv);
2219
2220         /* Register ourselves with the midlevel audio driver. */
2221         err = register_sparcaudio_driver(drv, 1);
2222
2223         if (err < 0) {
2224                 printk(KERN_ERR "cs4231: unable to register\n");
2225                 cs4231_disable_interrupts(drv);
2226                 free_irq(cs4231_chip->irq, drv);
2227                 sbus_iounmap(cs4231_chip->regs, cs4231_chip->regs_size);
2228                 kfree(drv->private);
2229                 return -EIO;
2230         }
2231
2232         cs4231_chip->perchip_info.play.active =
2233                 cs4231_chip->perchip_info.play.pause = 0;
2234
2235         cs4231_chip->perchip_info.record.active =
2236                 cs4231_chip->perchip_info.record.pause = 0;
2237
2238         cs4231_chip->perchip_info.play.avail_ports = (AUDIO_HEADPHONE |
2239                                                       AUDIO_SPEAKER |
2240                                                       AUDIO_LINE_OUT);
2241
2242         cs4231_chip->perchip_info.record.avail_ports = (AUDIO_INTERNAL_CD_IN |
2243                                                         AUDIO_LINE_IN |
2244                                                         AUDIO_MICROPHONE |
2245                                                         AUDIO_ANALOG_LOOPBACK);
2246
2247         /* Announce the hardware to the user. */
2248         printk(KERN_INFO "audio%d: cs4231%c at %lx irq %s\n",
2249                drv->index, (cs4231_chip->status & CS_STATUS_REV_A) ? 'a' : ' ',
2250                cs4231_chip->regs, __irq_itoa(cs4231_chip->irq));
2251
2252         /* Success! */
2253         return 0;
2254 }
2255
2256 #ifdef EB4231_SUPPORT
2257 /* Attach to an cs4231 chip given its PROM node. */
2258 static int eb4231_attach(struct sparcaudio_driver *drv,
2259                          struct linux_ebus_device *edev)
2260 {
2261         struct cs4231_chip *cs4231_chip;
2262         int len, err, nregs;
2263         struct linux_prom_registers regs[4];
2264
2265         /* Allocate our private information structure. */
2266         drv->private = kmalloc(sizeof(struct cs4231_chip), GFP_KERNEL);
2267         if (drv->private == NULL)
2268                 return -ENOMEM;
2269
2270         /* Point at the information structure and initialize it. */
2271         drv->ops = &eb4231_ops;
2272         cs4231_chip = (struct cs4231_chip *) drv->private;
2273         cs4231_chip->input_ptr = cs4231_chip->output_ptr = NULL;
2274         cs4231_chip->input_size = cs4231_chip->output_size = 0;
2275         cs4231_chip->status = 0;
2276
2277         drv->dev = (struct sbus_dev *)edev->bus->self;
2278
2279         len = prom_getproperty(edev->prom_node, "reg", (void *)regs, sizeof(regs));
2280         if ((len % sizeof(regs[0])) != 0) {
2281                 printk("eb4231: Strange reg property size %d\n", len);
2282                 return -ENODEV;
2283         }
2284
2285         nregs = len / sizeof(regs[0]);
2286         cs4231_chip->regs = (unsigned long)ioremap(edev->resource[0].start, 0x10);
2287         cs4231_chip->eb2p = (unsigned long)ioremap(edev->resource[1].start, 0x10);
2288         cs4231_chip->eb2c = (unsigned long)ioremap(edev->resource[2].start, 0x10);
2289
2290         cs4231_chip->status |= CS_STATUS_IS_EBUS;
2291
2292         /* Attach the interrupt handler to the audio interrupt. */
2293         cs4231_chip->irq = edev->irqs[0];
2294         cs4231_chip->irq2 = edev->irqs[1];
2295
2296         if(request_irq(cs4231_chip->irq, eb4231_cinterrupt, SA_SHIRQ, "cs4231", drv) ||
2297            request_irq(cs4231_chip->irq2, eb4231_pinterrupt, SA_SHIRQ, "cs4231", drv))
2298                 goto bail;
2299
2300         cs4231_chip->nirqs = 2;
2301         cs4231_enable_interrupts(drv);
2302
2303         /* Reset the audio chip. */
2304         cs4231_chip_reset(drv);
2305
2306         /* Register ourselves with the midlevel audio driver. */
2307         err = register_sparcaudio_driver(drv, 1);
2308
2309         if (err < 0) {
2310         bail:
2311                 printk(KERN_ERR "cs4231: unable to register\n");
2312                 cs4231_disable_interrupts(drv);
2313                 free_irq(cs4231_chip->irq, drv);
2314                 free_irq(cs4231_chip->irq2, drv);
2315                 kfree(drv->private);
2316                 return -EIO;
2317         }
2318
2319         cs4231_chip->perchip_info.play.active =
2320                 cs4231_chip->perchip_info.play.pause = 0;
2321
2322         cs4231_chip->perchip_info.record.active =
2323                 cs4231_chip->perchip_info.record.pause = 0;
2324
2325         cs4231_chip->perchip_info.play.avail_ports = (AUDIO_HEADPHONE |
2326                                                       AUDIO_SPEAKER |
2327                                                       AUDIO_LINE_OUT);
2328
2329         cs4231_chip->perchip_info.record.avail_ports = (AUDIO_INTERNAL_CD_IN |
2330                                                         AUDIO_LINE_IN |
2331                                                         AUDIO_MICROPHONE |
2332                                                         AUDIO_ANALOG_LOOPBACK);
2333
2334         /* Announce the hardware to the user. */
2335         printk(KERN_INFO "audio%d: cs4231%c(eb2) at %lx irq %s\n",
2336                drv->index, (cs4231_chip->status & CS_STATUS_REV_A) ? 'a' : ' ',
2337                cs4231_chip->regs, __irq_itoa(cs4231_chip->irq));
2338
2339         /* Success! */
2340         return 0;
2341 }
2342 #endif
2343
2344 #ifdef EB4231_SUPPORT
2345 static int __init ebus_cs4231_p(struct linux_ebus_device *edev)
2346 {
2347         if (!strcmp(edev->prom_name, "SUNW,CS4231"))
2348                 return 1;
2349         if (!strcmp(edev->prom_name, "audio")) {
2350                 char compat[16];
2351
2352                 prom_getstring(edev->prom_node, "compatible",
2353                                compat, sizeof(compat));
2354                 compat[15] = '\0';
2355                 if (!strcmp(compat, "SUNW,CS4231"))
2356                         return 1;
2357         }
2358
2359         return 0;
2360 }
2361 #endif
2362
2363 /* Detach from an cs4231 chip given the device structure. */
2364 static void __exit cs4231_detach(struct sparcaudio_driver *drv)
2365 {
2366         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
2367
2368         cs4231_disable_interrupts(drv);
2369         unregister_sparcaudio_driver(drv, 1);
2370         free_irq(cs4231_chip->irq, drv);
2371         if (!(cs4231_chip->status & CS_STATUS_IS_EBUS)) {
2372                 sbus_iounmap(cs4231_chip->regs, cs4231_chip->regs_size);
2373         } else {
2374 #ifdef EB4231_SUPPORT
2375                 iounmap(cs4231_chip->regs);
2376                 iounmap(cs4231_chip->eb2p);
2377                 iounmap(cs4231_chip->eb2c);
2378                 free_irq(cs4231_chip->irq2, drv);
2379 #endif
2380         }
2381         kfree(drv->private);
2382 }
2383
2384
2385 /* Probe for the cs4231 chip and then attach the driver. */
2386 static int __init cs4231_init(void)
2387 {
2388         struct sbus_bus *sbus;
2389         struct sbus_dev *sdev;
2390 #ifdef EB4231_SUPPORT
2391         struct linux_ebus *ebus;
2392         struct linux_ebus_device *edev;
2393 #endif
2394
2395         num_drivers = 0;
2396
2397         /* Probe each SBUS for cs4231 chips. */
2398         for_all_sbusdev(sdev, sbus) {
2399                 if (!strcmp(sdev->prom_name, "SUNW,CS4231")) {
2400                         /* Don't go over the max number of drivers. */
2401                         if (num_drivers >= MAX_DRIVERS)
2402                                 continue;
2403
2404                         if (cs4231_attach(&drivers[num_drivers], sdev) == 0)
2405                                 num_drivers++;
2406                 }
2407         }
2408
2409 #ifdef EB4231_SUPPORT
2410         for_each_ebus(ebus) {
2411                 for_each_ebusdev(edev, ebus) {
2412                         if (ebus_cs4231_p(edev)) {
2413                                 /* Don't go over the max number of drivers. */
2414                                 if (num_drivers >= MAX_DRIVERS)
2415                                         continue;
2416
2417                                 if (eb4231_attach(&drivers[num_drivers], edev) == 0)
2418                                         num_drivers++;
2419                         }
2420                 }
2421         }
2422 #endif
2423
2424         /* Only return success if we found some cs4231 chips. */
2425         return (num_drivers > 0) ? 0 : -EIO;
2426 }
2427
2428 static void __exit cs4231_exit(void)
2429 {
2430         register int i;
2431
2432         for (i = 0; i < num_drivers; i++) {
2433                 cs4231_detach(&drivers[i]);
2434                 num_drivers--;
2435         }
2436 }
2437
2438 module_init(cs4231_init);
2439 module_exit(cs4231_exit);
2440 MODULE_LICENSE("GPL");
2441 /*
2442  * Overrides for Emacs so that we follow Linus's tabbing style.
2443  * Emacs will notice this stuff at the end of the file and automatically
2444  * adjust the settings for this buffer only.  This must remain at the end
2445  * of the file.
2446  * ---------------------------------------------------------------------------
2447  * Local variables:
2448  * c-indent-level: 4
2449  * c-brace-imaginary-offset: 0
2450  * c-brace-offset: -4
2451  * c-argdecl-indent: 4
2452  * c-label-offset: -4
2453  * c-continued-statement-offset: 4
2454  * c-continued-brace-offset: 0
2455  * indent-tabs-mode: nil
2456  * tab-width: 8
2457  * End:
2458  */