开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
cs4231.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：83k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

cs4231.c：源码内容
  1. /* $Id: cs4231.c,v 1.47 2001/10/08 22:19:50 davem 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.  */
  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
  44. #include <asm/audioio.h>
  45. #include "cs4231.h"
  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
  66. #define MAX_DRIVERS 1
  67. static struct sparcaudio_driver drivers[MAX_DRIVERS];
  68. static int num_drivers;
  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
  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)
  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;
  105.         tprintk(("enabling interruptsn"));
  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. }
  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;
  122.         tprintk(("disabling interruptsn"));
  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. }
  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;
  138.         tprintk(("enabling playn"));
  139.         save_flags(flags);
  140.         cli();
  141.         WRITE_IAR(0x9);
  142.         WRITE_IDR(READ_IDR() | PEN_ENABLE);
  143.         restore_flags(flags);
  144. }
  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;
  151.         tprintk(("disabling playn"));
  152.         save_flags(flags);
  153.         cli();
  154.         WRITE_IAR(0x9);
  155.         WRITE_IDR(READ_IDR() & PEN_DISABLE);
  156.         restore_flags(flags);
  157. }
  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;
  164.         tprintk(("enabling recn"));
  165.         save_flags(flags);
  166.         cli();
  167.         WRITE_IAR(0x9);
  168.         WRITE_IDR(READ_IDR() | CEN_ENABLE);
  169.         restore_flags(flags);
  170. }
  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;
  177.         tprintk(("disabling recn"));
  178.         save_flags(flags);
  179.         cli();
  180.         WRITE_IAR(0x9);
  181.         WRITE_IDR(READ_IDR() & CEN_DISABLE);
  182.         restore_flags(flags);
  183. }
  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. };
  204. #define NUM_RATES (sizeof(cs4231_rate_table) / sizeof(struct cs4231_rates))
  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;
  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;
  217.         for (i = 0; i < NUM_RATES; i++, p++) {
  218.                 /* Exact match? */
  219.                 if (wanted == p->speed)
  220.                         break;
  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;
  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. }
  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. }
  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;
  277.         tprintk(("output encoding %dn", 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 failedn"));
  294.         return -EINVAL;
  295. }
  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. }
  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;
  308.         tprintk(("input encoding %dn", 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();
  321.                         cs4231_chip->perchip_info.record.encoding = value;
  322.                         return 0;
  323.                 }
  324.         }
  325.         dprintk(("input enc failedn"));
  326.         return -EINVAL;
  327. }
  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. }
  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;
  340.         tprintk(("output rate %dn", 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();
  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 failedn"));
  360.         return -EINVAL;
  361. }
  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. }
  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;
  374.         tprintk(("input rate %dn", 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();
  387.                         cs4231_chip->perchip_info.record.sample_rate = value;
  388.                         return 0;
  389.                 }
  390.         }
  391.         dprintk(("input rate failedn"));
  392.         return -EINVAL;
  393. }
  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. }
  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;
  407.         tprintk(("input channels %dn", 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 failedn"));
  419.                 return -EINVAL;
  420.         };
  421.         CHIP_READY();
  423.         cs4231_chip->perchip_info.record.channels = value;
  424.         return 0;
  425. }
  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. }
  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;
  439.         tprintk(("output channels %dn", 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 failedn"));
  451.                 return -EINVAL;
  452.         };
  453.         CHIP_READY();
  454.     
  455. cs4231_chip->perchip_info.play.channels = value;
  456.         return 0;
  457. }
  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. }
  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. }
  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. }
  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;
  481.       cs4231_chip->perchip_info.record.precision = val;
  483.       return cs4231_chip->perchip_info.record.precision;
  484. }
  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; 
  490.       cs4231_chip->perchip_info.play.precision = val;
  492.       return cs4231_chip->perchip_info.play.precision;
  493. }
  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;
  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);
  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. }
  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: %dn", 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. }
  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. }
  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. }
  552. static int cs4231_get_output_ports(struct sparcaudio_driver *drv)
  553. {
  554.         return (AUDIO_LINE_OUT | AUDIO_SPEAKER | AUDIO_HEADPHONE);
  555. }
  557. static int cs4231_get_input_ports(struct sparcaudio_driver *drv)
  558. {
  559.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  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. }
  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;
  575.         tprintk(("output port: %dn", 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);
  585.         if (value & AUDIO_SPEAKER) {
  586.                 WRITE_IAR(0x1a);
  587.                 WRITE_IDR(READ_IDR() & ~MONO_IOCR_MUTE);
  588.                 retval |= AUDIO_SPEAKER;
  589.         }
  591.         if (value & AUDIO_HEADPHONE) {
  592.                 WRITE_IAR(0x0a);
  593.                 WRITE_IDR(READ_IDR() & ~PINCR_HDPH_MUTE);
  594.                 retval |= AUDIO_HEADPHONE;
  595.         }
  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;
  605.         return (retval);
  606. }
  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. }
  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;
  620.         tprintk(("input port: %dn", value));
  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.          */
  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.         }
  658.         cs4231_chip->perchip_info.record.port = retval;
  660.         return retval;
  661. }
  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. }
  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;
  675.         tprintk(("monitor gain: %dn", value));
  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));
  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);
  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));
  697.         return 0;
  698. }
  700. static int cs4231_get_monitor_volume(struct sparcaudio_driver *drv)
  701. {
  702.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  704.         return (int) cs4231_chip->perchip_info.monitor_gain;
  705. }
  707. static int cs4231_get_output_error(struct sparcaudio_driver *drv)
  708. {
  709.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  711.         return (int) cs4231_chip->perchip_info.play.error;
  712. }
  714. static int cs4231_get_input_error(struct sparcaudio_driver *drv)
  715. {
  716.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  718.         return (int) cs4231_chip->perchip_info.record.error;
  719. }
  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);
  729.         return (cs4231_chip->perchip_info.play.samples - 
  730.                 ((count > cs4231_chip->perchip_info.play.samples) 
  731.                  ? 0 : count));
  732. }
  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);
  741.         return (cs4231_chip->perchip_info.record.samples - 
  742.                 ((count > cs4231_chip->perchip_info.record.samples) ?
  743.                 0 : count));
  744. }
  745. #endif
  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);
  754.         return (cs4231_chip->perchip_info.play.samples - 
  755.                 ((count > cs4231_chip->perchip_info.play.samples) 
  756.                  ? 0 : count));
  757. }
  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);
  766.         return (cs4231_chip->perchip_info.record.samples - 
  767.                 ((count > cs4231_chip->perchip_info.record.samples) ?
  768.                 0 : count));
  769. }
  771. static int cs4231_get_output_pause(struct sparcaudio_driver *drv)
  772. {
  773.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  775.         return (int) cs4231_chip->perchip_info.play.pause;
  776. }
  778. static int cs4231_get_input_pause(struct sparcaudio_driver *drv)
  779. {
  780.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  782.         return (int) cs4231_chip->perchip_info.record.pause;
  783. }
  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;
  792. cs4231_record_gain(drv, value, 
  793.                            cs4231_chip->perchip_info.record.balance);
  795.         return 0;
  796. }
  798. static int cs4231_get_input_volume(struct sparcaudio_driver *drv)
  799. {
  800.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  802.         return (int) cs4231_chip->perchip_info.record.gain;
  803. }
  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;
  809. cs4231_play_gain(drv, value, cs4231_chip->perchip_info.play.balance);
  811.         return 0;
  812. }
  814. static int cs4231_get_output_volume(struct sparcaudio_driver *drv)
  815. {
  816.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  818.         return cs4231_chip->perchip_info.play.gain;
  819. }
  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;
  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);
  830.         return 0;
  831. }
  833. static int cs4231_get_input_balance(struct sparcaudio_driver *drv)
  834. {
  835.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  837.         return (int) cs4231_chip->perchip_info.record.balance;
  838. }
  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;
  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);
  848.         return 0;
  849. }
  851. static int cs4231_get_output_balance(struct sparcaudio_driver *drv)
  852. {
  853.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  855.         return (int) cs4231_chip->perchip_info.play.balance;
  856. }
  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;
  866.         r = l = value;
  868.         if (balance < AUDIO_MID_BALANCE) {
  869.                 r = (int) (value -
  870.                            ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT));
  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));
  878.                 if (l < 0)
  879.                         l = 0;
  880.         }
  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. }
  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;
  911.         tprintk(("in play_gain: %d %cn", value, balance));
  912.         r = l = value;
  913.         if (balance < AUDIO_MID_BALANCE) {
  914.                 r = (int) (value -
  915.                            ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT));
  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));
  923.                 if (l < 0)
  924.                         l = 0;
  925.         }
  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;
  954.         return 0;
  955. }
  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;
  963.         tprintk(("in cs4231_chip_resetn"));
  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;
  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.         }
  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);
  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);
  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);
  1005.         WRITE_IAR(0x19);
  1007.         /* see what we can turn on */
  1008.         vers = READ_IDR();
  1009.         if (vers & CS4231A) {
  1010.                 tprintk(("This is a CS4231An"));
  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);
  1032.         cs4231_set_input_volume(drv, CS4231_DEFAULT_RECGAIN);
  1033.         cs4231_set_output_volume(drv, CS4231_DEFAULT_PLAYGAIN);
  1035.         cs4231_set_input_port(drv, AUDIO_MICROPHONE);
  1036.         cs4231_set_output_port(drv, AUDIO_SPEAKER);
  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);
  1050.         cs4231_output_muted(drv, 0);
  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;
  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. }
  1065. static int
  1066. cs4231_length_to_samplecount(struct audio_prinfo *thisdir, unsigned int length)
  1067. {
  1068.         unsigned int count;
  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. }
  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;
  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
  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;
  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);
  1136.         /* normalize for where we are. */
  1137.         thisdir->samples = ((count - nextcount) + (length - curcount));
  1138. }
  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;
  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.         }
  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.         }  
  1163.         cs4231_ready(drv);
  1164.         CHIP_READY();
  1165.     
  1166.         MOD_INC_USE_COUNT;
  1167.   
  1168.         return 0;
  1169. }
  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;
  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.         }
  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.         }
  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.         }
  1230.         MOD_DEC_USE_COUNT;
  1231. }
  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;
  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.         }
  1249.         if (cs4231_chip->playlen == 0 && cs4231_chip->output_size > 0) 
  1250.                 cs4231_chip->playlen = cs4231_chip->output_size;
  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.         }
  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.         }
  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.         }
  1291.         sparcaudio_output_done(drv, status);
  1292. }
  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;
  1300.         if (cs4231_chip->playlen == 0 && cs4231_chip->output_size > 0) 
  1301.                 cs4231_chip->playlen = cs4231_chip->output_size;
  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.         }
  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.         }
  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;
  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.         }
  1340.         sparcaudio_output_done(drv, status);
  1341. }
  1342. #endif
  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. }
  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;
  1364.         if (cs4231_chip->perchip_info.record.active == 0) {
  1365.                 dprintk(("going inactiven"));
  1366.                 cs4231_pollinput(drv);
  1367.                 cs4231_disable_rec(drv);    
  1368.         } 
  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.         }
  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.         }
  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.         }
  1412.         sparcaudio_input_done(drv, status);
  1413.         return 1;
  1414. }
  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;
  1422.         if (cs4231_chip->perchip_info.record.active == 0) {
  1423.                 dprintk(("going inactiven"));
  1424.                 eb4231_pollinput(drv);
  1425.                 cs4231_disable_rec(drv);    
  1426.         } 
  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.         }
  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.         }
  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);
  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;
  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);
  1464.                 cs4231_chip->input_size = 0;
  1465.                 cs4231_chip->input_ptr = NULL;
  1466.                 cs4231_chip->recording_count++;
  1467.                 status += 2;
  1468.         }
  1470.         sparcaudio_input_done(drv, status);
  1471.         return 1;
  1472. }
  1473. #endif
  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;
  1482.         cs4231_chip->output_ptr = buffer;
  1483.         cs4231_chip->output_size = count;
  1485.         if (cs4231_chip->perchip_info.play.active || 
  1486.             (cs4231_chip->perchip_info.play.pause))
  1487.                 return;
  1489.         cs4231_ready(drv);
  1491.         cs4231_chip->perchip_info.play.active = 1;
  1492.         cs4231_chip->playing_count = 0;
  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);
  1499.                 eb4231_playintr(drv);
  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);
  1506.                 cs4231_enable_play(drv);
  1508.                 cs4231_ready(drv);
  1509.         } else {
  1510.                 eb4231_playintr(drv);
  1511.         }
  1512. }
  1513. #endif
  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;
  1521.         tprintk(("in 4231 start outputn"));
  1522.         cs4231_chip->output_ptr = buffer;
  1523.         cs4231_chip->output_size = count;
  1525.         if (cs4231_chip->perchip_info.play.active || 
  1526.             (cs4231_chip->perchip_info.play.pause))
  1527.                 return;
  1529.         cs4231_ready(drv);
  1531.         cs4231_chip->perchip_info.play.active = 1;
  1532.         cs4231_chip->playing_count = 0;
  1534.         csr = sbus_readl(cs4231_chip->regs + APCCSR);
  1535.         if ((csr & APC_PPAUSE) || !(csr & APC_PDMA_READY)) {
  1536.                 u32 pnva;
  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);
  1546.                 csr |= APC_PLAY_SETUP;
  1547.                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
  1548.                 cs4231_enable_play(drv);
  1550.                 cs4231_ready(drv);
  1551.         }
  1552. }
  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;
  1560.         dprintk(("eb4231_stop_output: dcsr 0x%x dacr 0x%x dbcr %dn",
  1561.                  readl(cs4231_chip->eb2p + EBDMA_CSR),
  1562.                  readl(cs4231_chip->eb2p + EBDMA_ADDR),
  1563.                  readl(cs4231_chip->eb2p + EBDMA_COUNT)));
  1565.         cs4231_chip->output_ptr = NULL;
  1566.         cs4231_chip->output_size = 0;
  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.         }
  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);
  1590.         /* Else subsequent speed setting changes are ignored by the chip. */
  1591.         cs4231_disable_play(drv);
  1592. }
  1593. #endif
  1595. static void cs4231_stop_output(struct sparcaudio_driver *drv)
  1596. {
  1597.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  1599.         tprintk(("in cs4231_stop_outputn"));
  1600.         cs4231_chip->output_ptr = NULL;
  1601.         cs4231_chip->output_size = 0;
  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.         }
  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. }
  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;
  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);
  1641.         writel(dcsr | EBUS_DCSR_TC,
  1642.                cs4231_chip->eb2c + EBDMA_CSR);
  1643. }
  1644. #endif
  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;
  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);
  1660.         sbus_writel(csr | APC_XINT_CEMP,
  1661.                     cs4231_chip->regs + APCCSR);
  1662. }
  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;
  1670.         cs4231_chip->input_ptr = buffer;
  1671.         cs4231_chip->input_size = count;
  1673.         if (cs4231_chip->perchip_info.record.active || 
  1674.             (cs4231_chip->perchip_info.record.pause))
  1675.                 return;
  1677.         cs4231_ready(drv);
  1679.         cs4231_chip->perchip_info.record.active = 1;
  1680.         cs4231_chip->recording_count = 0;
  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);
  1689.                 cs4231_recintr(drv);
  1691.                 csr |= APC_CAPT_SETUP;
  1692.                 sbus_writel(csr, cs4231_chip->regs + APCCSR);
  1694.                 cs4231_enable_rec(drv);
  1695.                 cs4231_ready(drv);
  1696.         } else {
  1697.                 cs4231_recintr(drv);
  1698.         }
  1699. }
  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;
  1706.         cs4231_chip->perchip_info.record.active = 0;
  1708.         csr = sbus_readl(cs4231_chip->regs + APCCSR);
  1709.         csr |= APC_CPAUSE;
  1710.         sbus_writel(csr, cs4231_chip->regs + APCCSR);
  1712.         cs4231_chip->input_ptr = NULL;
  1713.         cs4231_chip->input_size = 0;
  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.         }
  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.         }
  1733.         cs4231_pollinput(drv);
  1734. }
  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;
  1743.         cs4231_chip->input_ptr = buffer;
  1744.         cs4231_chip->input_size = count;
  1746.         if (cs4231_chip->perchip_info.record.active || 
  1747.             (cs4231_chip->perchip_info.record.pause))
  1748.                 return;
  1750.         cs4231_ready(drv);
  1751.         cs4231_chip->perchip_info.record.active = 1;
  1752.         cs4231_chip->recording_count = 0;
  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);
  1759.                 eb4231_recintr(drv);
  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);
  1766.                 cs4231_enable_rec(drv);
  1767.                 cs4231_ready(drv);
  1768.         } else {
  1769.                 eb4231_recintr(drv);
  1770.         }
  1771. }
  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;
  1778.         cs4231_chip->perchip_info.record.active = 0;
  1780.         cs4231_chip->input_ptr = NULL;
  1781.         cs4231_chip->input_size = 0;
  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.         }
  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.         }
  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);
  1805.         cs4231_disable_rec(drv);
  1806. }
  1807. #endif
  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;
  1813.         cs4231_chip->perchip_info.play.pause = value;
  1815.         if (!value)
  1816.                 sparcaudio_output_done(drv, 0);
  1818.         return value;
  1819. }
  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. }
  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. }
  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. }
  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;
  1862.         return i;
  1863. }
  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;
  1869.         cs4231_chip->perchip_info.record.pause = value;
  1871.         if (value)
  1872.                 cs4231_stop_input(drv);
  1874.         return value;
  1875. }
  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;
  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. }
  1897. static int cs4231_audio_getdev_sunos(struct sparcaudio_driver *drv)
  1898. {
  1899.         return AUDIO_DEV_CS4231;
  1900. }
  1902. static void cs4231_loopback(struct sparcaudio_driver *drv, unsigned int value)
  1903. {
  1904.         struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
  1906.         WRITE_IAR(0x0d);
  1907.         WRITE_IDR(value ? LOOPB_ON : 0);
  1908. }
  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.         };
  1926.         return retval;
  1927. }
  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);
  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.         }
  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. }
  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);
  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.         }
  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
  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_interruptn"));
  1997.         /* Clear the interrupt. */
  1998.         dummy = sbus_readl(cs4231_chip->regs + APCCSR);
  1999.         sbus_writel(dummy, cs4231_chip->regs + APCCSR);
  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.         }
  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.         }
  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.         }
  2035.         if (dummy & APC_XINT_EMPT) {
  2036.                 if (!cs4231_chip->output_next_dma_handle) {
  2037.                         u32 csr = sbus_readl(cs4231_chip->regs + APCCSR);
  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);
  2047.                 cs4231_getsamplecount(drv, cs4231_chip->playlen, 0);
  2048.         }
  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. }
  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. };
  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
  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;
  2184.         /* Allocate our private information structure. */
  2185.         drv->private = kmalloc(sizeof(struct cs4231_chip), GFP_KERNEL);
  2186.         if (drv->private == NULL)
  2187.                 return -ENOMEM;
  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;
  2196.         drv->dev = sdev;
  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");
  2204.         if (!cs4231_chip->regs) {
  2205.                 printk(KERN_ERR "cs4231: could not remap registersn");
  2206.                 kfree(drv->private);
  2207.                 return -EIO;
  2208.         }
  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);
  2214.         cs4231_chip->nirqs = 1;
  2215.         cs4231_enable_interrupts(drv);
  2217.         /* Reset the audio chip. */
  2218.         cs4231_chip_reset(drv);
  2220.         /* Register ourselves with the midlevel audio driver. */
  2221.         err = register_sparcaudio_driver(drv, 1);
  2223.         if (err < 0) {
  2224.                 printk(KERN_ERR "cs4231: unable to registern");
  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.         }
  2232.         cs4231_chip->perchip_info.play.active = 
  2233.                 cs4231_chip->perchip_info.play.pause = 0;
  2235.         cs4231_chip->perchip_info.record.active = 
  2236.                 cs4231_chip->perchip_info.record.pause = 0;
  2238.         cs4231_chip->perchip_info.play.avail_ports = (AUDIO_HEADPHONE |
  2239.                                                       AUDIO_SPEAKER |
  2240.                                                       AUDIO_LINE_OUT);
  2242.         cs4231_chip->perchip_info.record.avail_ports = (AUDIO_INTERNAL_CD_IN |
  2243.                                                         AUDIO_LINE_IN | 
  2244.                                                         AUDIO_MICROPHONE |
  2245.                                                         AUDIO_ANALOG_LOOPBACK);
  2247.         /* Announce the hardware to the user. */
  2248.         printk(KERN_INFO "audio%d: cs4231%c at %lx irq %sn",
  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. }
  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];
  2265.         /* Allocate our private information structure. */
  2266.         drv->private = kmalloc(sizeof(struct cs4231_chip), GFP_KERNEL);
  2267.         if (drv->private == NULL)
  2268.                 return -ENOMEM;
  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;
  2277.         drv->dev = (struct sbus_dev *)edev->bus->self;
  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 %dn", len);
  2282.                 return -ENODEV;
  2283.         }
  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);
  2290.         cs4231_chip->status |= CS_STATUS_IS_EBUS;
  2292.         /* Attach the interrupt handler to the audio interrupt. */
  2293.         cs4231_chip->irq = edev->irqs[0];
  2294.         cs4231_chip->irq2 = edev->irqs[1];
  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;
  2300.         cs4231_chip->nirqs = 2;
  2301.         cs4231_enable_interrupts(drv);
  2303.         /* Reset the audio chip. */
  2304.         cs4231_chip_reset(drv);
  2306.         /* Register ourselves with the midlevel audio driver. */
  2307.         err = register_sparcaudio_driver(drv, 1);
  2309.         if (err < 0) {
  2310.         bail:
  2311.                 printk(KERN_ERR "cs4231: unable to registern");
  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.         }
  2319.         cs4231_chip->perchip_info.play.active = 
  2320.                 cs4231_chip->perchip_info.play.pause = 0;
  2322.         cs4231_chip->perchip_info.record.active = 
  2323.                 cs4231_chip->perchip_info.record.pause = 0;
  2325.         cs4231_chip->perchip_info.play.avail_ports = (AUDIO_HEADPHONE |
  2326.                                                       AUDIO_SPEAKER |
  2327.                                                       AUDIO_LINE_OUT);
  2329.         cs4231_chip->perchip_info.record.avail_ports = (AUDIO_INTERNAL_CD_IN |
  2330.                                                         AUDIO_LINE_IN | 
  2331.                                                         AUDIO_MICROPHONE |
  2332.                                                         AUDIO_ANALOG_LOOPBACK);
  2334.         /* Announce the hardware to the user. */
  2335.         printk(KERN_INFO "audio%d: cs4231%c(eb2) at %lx irq %sn",
  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
  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];
  2352.                 prom_getstring(edev->prom_node, "compatible",
  2353.                                compat, sizeof(compat));
  2354.                 compat[15] = '';
  2355.                 if (!strcmp(compat, "SUNW,CS4231"))
  2356.                         return 1;
  2357.         }
  2359.         return 0;
  2360. }
  2361. #endif
  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;
  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. }
  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
  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
  2424.         /* Only return success if we found some cs4231 chips. */
  2425.         return (num_drivers > 0) ? 0 : -EIO;
  2426. }
  2428. static void __exit cs4231_exit(void)
  2429. {
  2430.         register int i;
  2432.         for (i = 0; i < num_drivers; i++) {
  2433.                 cs4231_detach(&drivers[i]);
  2434.                 num_drivers--;
  2435.         }
  2436. }
  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.  */