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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
sb16drv.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：24k
源码类别：

VxWorks

开发平台：

C/C++

sb16drv.c：源码内容
  1. /* sb16drv.c - Sound Blaster 16 driver implemented for Cyrix MediaGXi CPU */
  2. /* $Revision: 1.5 $ */
  3. /* Copyright 1999-2001 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01d,21sep01,dat  Fix ANSI violations for diab compiler
  9. 01c,27jan00,dmh  Corrected loop bug for audio on small buffers
  10. 01b,27oct99,spm  Sounds clean now, but record is still not implemented.
  11. 01a,03oct99,spm  created.  8 bit sound is still not working right.
  12. */
  14. #include "vxWorks.h"
  15. #include "errno.h"
  16. #include "fcntl.h"
  17. #include "intLib.h"
  18. #include "ioLib.h"
  19. #include "iosLib.h"
  20. #include "iv.h"
  21. #include "logLib.h"
  22. #include "lstLib.h"
  23. #include "msgQLib.h"
  24. #include "semLib.h"
  25. #include "stdlib.h"
  26. #include "string.h"
  27. #include "taskLib.h"
  29. #include "drv/sound/sb16drv.h"
  31. /* System function not in any include file.
  32.  */
  33. /* extern char *sysDmaMalloc (int); */
  35. char snd_dmaBuffer[MAX_DMA_MSGS * MAX_DMA_SIZE];
  37. LOCAL int DrvNum;
  39. static const MIXER_INFO mixerTable[] =
  40. {
  41.   {"master",  SB_MIXER_MASTER_DEV,  31, 3, 0},
  42.   {"pcm",     SB_MIXER_PCM_DEV,     31, 3, 0},
  43.   {"synth",   SB_MIXER_SYNTH_DEV,   31, 3, 0},
  44.   {"cd",      SB_MIXER_CD_DEV,      31, 3, 0},
  45.   {"line",    SB_MIXER_LINE_DEV,    31, 3, 0},
  46.   {"mic",     SB_MIXER_MIC_DEV,     31, 3, 0},
  47.   {"speaker", SB_MIXER_SPEAKER_DEV,  3, 6, 1},
  48.   {"igain",   SB_MIXER_OGAIN_DEV,    3, 6, 1},
  49.   {"ogain",   SB_MIXER_IGAIN_DEV,    3, 6, 1},
  50.   {"treble",  SB_MIXER_TREBLE_DEV,   7, 4, 1},
  51.   {"bass",    SB_MIXER_BASS_DEV,     7, 4, 1},
  52.   {NULL,      0,                     0, 0, 0}
  53. };
  55. /**
  56.     uLaw to PCM table
  57.     Used only for uLaw 8 bit.
  58. */
  59. char ulaw_dsp[] = {
  60.      3,    7,   11,   15,   19,   23,   27,   31,
  61.     35,   39,   43,   47,   51,   55,   59,   63,
  62.     66,   68,   70,   72,   74,   76,   78,   80,
  63.     82,   84,   86,   88,   90,   92,   94,   96,
  64.     98,   99,  100,  101,  102,  103,  104,  105,
  65.     106,  107,  108,  109,  110,  111,  112,  113,
  66.     113,  114,  114,  115,  115,  116,  116,  117,
  67.     117,  118,  118,  119,  119,  120,  120,  121,
  68.     121,  121,  122,  122,  122,  122,  123,  123,
  69.     123,  123,  124,  124,  124,  124,  125,  125,
  70.     125,  125,  125,  125,  126,  126,  126,  126,
  71.     126,  126,  126,  126,  127,  127,  127,  127,
  72.     127,  127,  127,  127,  127,  127,  127,  127,
  73.     128,  128,  128,  128,  128,  128,  128,  128,
  74.     128,  128,  128,  128,  128,  128,  128,  128,
  75.     128,  128,  128,  128,  128,  128,  128,  128,
  76.     253,  249,  245,  241,  237,  233,  229,  225,
  77.     221,  217,  213,  209,  205,  201,  197,  193,
  78.     190,  188,  186,  184,  182,  180,  178,  176,
  79.     174,  172,  170,  168,  166,  164,  162,  160,
  80.     158,  157,  156,  155,  154,  153,  152,  151,
  81.     150,  149,  148,  147,  146,  145,  144,  143,
  82.     143,  142,  142,  141,  141,  140,  140,  139,
  83.     139,  138,  138,  137,  137,  136,  136,  135,
  84.     135,  135,  134,  134,  134,  134,  133,  133,
  85.     133,  133,  132,  132,  132,  132,  131,  131,
  86.     131,  131,  131,  131,  130,  130,  130,  130,
  87.     130,  130,  130,  130,  129,  129,  129,  129,
  88.     129,  129,  129,  129,  129,  129,  129,  129,
  89.     128,  128,  128,  128,  128,  128,  128,  128,
  90.     128,  128,  128,  128,  128,  128,  128,  128,
  91.     128,  128,  128,  128,  128,  128,  128,  128,
  92. };
  94. /* Useful macros.
  95.  */
  96. #define IS_16BITS(x) ((x)->info.sampleSize == 16)
  98. /* Device Methods...
  99.  */
  100. static int sndCreate (SND_DEV *pDev, char *fileName, int mode);
  101. static int sndOpen (SND_DEV *pDev, char *fileName, int flags, int mode);
  102. static int sndClose (int devId);
  103. static int sndRead (int devId, char *buffer, int maxbytes);
  104. static int sndWrite (int devId, char *buffer, int nbytes);
  105. static int sndIoctl (int devId, int function, int arg);
  107. static int dspClose (int devId);
  108. static int dspRead (int devId, char *buffer, int maxbytes);
  109. static int dspWrite (int devId, char *buffer, int nbytes);
  110. static int dspIoctl (int devId, int function, int arg);
  112. static int mixerClose (int devId);
  113. static int mixerRead (int devId, char *buffer, int maxbytes);
  114. static int mixerWrite (int devId, char *buffer, int nbytes);
  115. static int mixerIoctl (int devId, int function, int arg);
  117. /* Interrupt handler and Helper task
  118.  */
  119. static void dspInterrupt (SND_DEV *pDev);
  120. static int dspHelperTask (SND_DEV *pDev);
  122. /* DMA buffer management routines
  123.  */
  124. static int createDmaBuffer (void);
  125. static char *getDmaBuffer (SND_DEV *pDev);
  126. static void freeDmaBuffer (SND_DEV *pDev);
  128. /* Low level register access routines.
  129.  */
  130. static int dsp_init (SND_DEV *pDev);
  131. static int dsp_version (SND_DEV *pDev);
  132. static int dsp_reset (SND_DEV *pDev);
  134. /* OPL3 functions...
  135.  */
  136. static int opl3_init (SND_DEV *pDev);
  138. /* Mixer functions...
  139.  */
  140. static int mixer_init (SND_DEV *pDev);
  142. /* Inlined small functions
  143.  */
  144. static __inline__ int dsp_command (SND_DEV *pDev, unsigned char val)
  145. {
  146.   int i;
  148.   for (i = 10000; i; i--)
  149.     if ((sysInByte (SBP(pDev, STATUS)) & 0x80) == 0)
  150.     {
  151.       sysOutByte (SBP(pDev, COMMAND), val);
  152.       return 1;
  153.     }
  154.   return 0;
  155. }
  157. static __inline__ int opl3_command (unsigned short port,
  158.     unsigned char reg, unsigned char val)
  159. {
  160.   sysOutByte (port, reg);
  161.   sysInByte (port);
  162.   sysInByte (port);
  164.   sysOutByte (port + 1, val);
  165.   sysInByte (port + 1);
  166.   sysInByte (port + 1);
  168.   return 1;
  169. }
  171. static __inline__ int dsp_ack_8bit (SND_DEV * pDev)
  172. {
  173.   return sysInByte (SBP(pDev, DATA_AVAIL));
  174. }
  176. static __inline__ int dsp_ack_16bit (SND_DEV * pDev)
  177. {
  178.   return sysInByte (SBP(pDev, DATA_AVAIL_16));
  179. }
  181. static __inline__ void mixer_write (SND_DEV *pDev,
  182.     unsigned char reg, unsigned char data)
  183. {
  184.   sysOutByte (SBP(pDev, MIXER_ADDR), reg);
  185.   sysOutByte (SBP(pDev, MIXER_DATA), data);
  186. }
  188. static __inline__ unsigned char mixer_read (SND_DEV *pDev, unsigned char reg)
  189. {
  190.   unsigned char result;
  192.   sysOutByte (SBP(pDev, MIXER_ADDR), reg);
  193.   result = sysInByte (SBP(pDev, MIXER_DATA));
  194.   return result;
  195. }
  197. static __inline__ void mixer_set_level (SND_DEV * pDev, char *name, int value)
  198. {
  199.   const MIXER_INFO *info;
  200.   int lvalue = value%256;
  201.   int rvalue = value/256;
  203.   for (info=mixerTable; info->name && strcmp (info->name, name); info++);
  205.   if (info->name)
  206.   {
  207.       if (lvalue > 100) lvalue = 100;
  208.       else if (lvalue<0) lvalue = 0;
  209.       
  210.       lvalue = (lvalue * info->max_value / 100) << info->shift;
  212.       if (rvalue > 100) rvalue = 100;
  213.       else if (rvalue<0) rvalue = 0;
  214.       
  215.       rvalue = (rvalue * info->max_value / 100) << info->shift;
  217.       mixer_write (pDev, info->reg, lvalue);
  218.       mixer_write (pDev, info->reg + 1, rvalue);
  219.   }
  220. }
  222. static __inline__ int mixer_get_level (SND_DEV * pDev, char *name)
  223. {
  224.   const MIXER_INFO *info;
  226.   for (info=mixerTable; info->name && strcmp (info->name, name); info++);
  228.   if (info->name)
  229.   {
  230.       int lvalue = mixer_read (pDev, info->reg) >> info->shift;
  231.       int rvalue = mixer_read (pDev, info->reg + 1) >> info->shift;
  232.       lvalue = lvalue * 100 / info->max_value;
  233.       rvalue = rvalue * 100 / info->max_value;
  234.       return rvalue << 8 | lvalue;
  235.   }
  236.   return 0;
  237. }
  239. /* Routine to initiate Sound blaster DMAs.
  240.  */
  241. static void dsp_output (DSP_FD *pDsp, int length)
  242. {
  243.   SND_DEV *pDev = pDsp->dev.pDev;
  244.   unsigned long count;
  245.   unsigned char format;
  247.   /* setup the sample rate.
  248.    */
  249.   dsp_command (pDev, SB_DSP_SAMPLE_RATE_IN);
  250.   dsp_command (pDev, pDsp->info.rate >> 8);
  251.   dsp_command (pDev, pDsp->info.rate & 0xff);
  253.   dsp_command (pDev, SB_DSP_SAMPLE_RATE_OUT);
  254.   dsp_command (pDev, pDsp->info.rate >> 8);
  255.   dsp_command (pDev, pDsp->info.rate & 0xff);
  257.   /* Determine the proper format of the output.
  258.    */
  259.   if (IS_16BITS(pDsp))
  260.     format = pDsp->info.stereo ?
  261.       SB_DSP4_MODE_SIGN_STEREO : SB_DSP4_MODE_SIGN_MONO;
  262.   else
  263.     format = pDsp->info.stereo ?
  264.       SB_DSP4_MODE_UNS_STEREO : SB_DSP4_MODE_UNS_MONO;
  266.   /* Tell the sound hardware how many samples.
  267.    */
  268.   count = (IS_16BITS(pDsp) ? (length >> 1) : length) - 1;
  270.   dsp_command (pDev, IS_16BITS(pDsp) ? SB_DSP4_OUT16_AI : SB_DSP4_OUT8_AI);
  271.   dsp_command (pDev, format);
  272.   dsp_command (pDev, count & 0xff);
  273.   dsp_command (pDev, count >> 8);
  274.   dsp_command (pDev, IS_16BITS(pDev->pDsp) ?
  275.        SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
  276. }
  278. /* Device creation routines...
  279.  */
  280. STATUS sb16Drv (void)
  281. {
  283.   if (DrvNum > 0) return OK;
  285.   DrvNum = iosDrvInstall (sndCreate, NULL, sndOpen, sndClose,
  286.   sndRead, sndWrite, sndIoctl);
  288.   return (DrvNum == ERROR) ? ERROR : OK;
  289. }
  291. STATUS sb16DevCreate (char *devName, int port, int irq, int dma8, int dma16)
  292. {
  293.   SND_DEV *pDev;
  295.   if (DrvNum < 1)
  296.   {
  297.     errno = S_ioLib_NO_DRIVER;
  298.     return ERROR;
  299.   }
  301.   pDev = (SND_DEV *)malloc (sizeof(SND_DEV));
  302.   if (!pDev) return ERROR;
  304.   bzero ((char *)pDev, sizeof(SND_DEV));
  306.   pDev->port   = port;
  307.   pDev->irq    = irq;
  308.   pDev->dma8   = dma8;
  309.   pDev->dma16  = dma16;
  311.   pDev->devSem = semBCreate (SEM_Q_FIFO, SEM_FULL);
  312.   pDev->intSem = semCCreate (SEM_Q_FIFO, 0);
  313.   pDev->bufSem = semCCreate (SEM_Q_FIFO, MAX_DMA_MSGS);
  314.   pDev->dmaQ   = msgQCreate (MAX_DMA_MSGS, sizeof (DMA_MSG), MSG_Q_FIFO);
  316.   pDev->dmaIndex = 0;
  318.   if (createDmaBuffer () < 0)
  319.   {
  320.     free (pDev);
  321.     return ERROR;
  322.   }
  324.   if (dsp_init (pDev) < 0)
  325.   {
  326.     free (pDev);
  327.     return ERROR;
  328.   }
  330.   /* This belongs in the mixer device...
  331.    */
  332.   if (mixer_init (pDev) < 0)
  333.   {
  334.     free (pDev);
  335.     return ERROR;
  336.   }
  338.   if (iosDevAdd (&pDev->devHdr, devName, DrvNum) == ERROR)
  339.   {
  340.     free ((char *)pDev);
  341.     return ERROR;
  342.   }
  344.   pDev->tid = taskSpawn ("tSndTask", TASK_PRIORITY, TASK_OPTIONS,
  345.  TASK_STACK_SIZE, dspHelperTask, (int)pDev,
  346.  0, 0, 0, 0, 0, 0, 0, 0, 0);
  348.   if (pDev->tid == ERROR)
  349.   {
  350.     free (pDev);
  351.     return ERROR;
  352.   }
  354.   intConnect (INUM_TO_IVEC (INT_VEC_GET (irq)), dspInterrupt, (int)pDev);
  356.   return OK;
  357. }
  359. /* Device methods...
  360.  */
  361. static int sndCreate (SND_DEV *pDev, char *fileName, int mode)
  362. {
  363.   return ERROR;
  364. }
  366. static int sndOpen (SND_DEV *pDev, char *fileName, int flags, int mode)
  367. {
  368.   SND_FD *pSnd = NULL;
  370.   if (semTake (pDev->devSem, 30 * sysClkRateGet()))
  371.   {
  372.     errno = S_ioLib_DEVICE_ERROR;
  373.     return ERROR;
  374.   }
  376.   if (strcmp (fileName, "/dsp") == 0)
  377.   {
  378.     DSP_FD *pDsp;
  380.     if (pDev->pDsp)
  381.     {
  382.       errno = EBUSY;
  383.       goto error;
  384.     }
  386.     if (! (pDsp = malloc (sizeof(DSP_FD))))
  387.     {
  388.       errno = ENOMEM;
  389.       goto error;
  390.     }
  392.     pDsp->dev.pDev    = pDev;
  393.     pDsp->dev.fdClose = dspClose;
  394.     pDsp->dev.fdRead  = dspRead;
  395.     pDsp->dev.fdWrite = dspWrite;
  396.     pDsp->dev.fdIoctl = dspIoctl;
  398.     pDsp->info.rate       = RATE_MAX;
  399.     pDsp->info.stereo     = 1;
  400.     pDsp->info.sampleSize = 16;
  401.     pDsp->info.uLaw       = 0; /* PCM format is default */
  403.     pDev->pDsp = pDsp;
  405.     pSnd = (SND_FD *)pDsp;
  406.   }
  407.   else if (strcmp (fileName, "/mixer") == 0)
  408.   {
  409.     MIXER_FD *pMixer;
  411.     if (pDev->pMixer)
  412.     {
  413.       errno = EBUSY;
  414.       goto error;
  415.     }
  417.     if (! (pMixer = malloc (sizeof(MIXER_FD))))
  418.     {
  419.       errno = ENOMEM;
  420.       goto error;
  421.     }
  423.     pMixer->dev.pDev    = pDev;
  424.     pMixer->dev.fdClose = mixerClose;
  425.     pMixer->dev.fdRead  = mixerRead;
  426.     pMixer->dev.fdWrite = mixerWrite;
  427.     pMixer->dev.fdIoctl = mixerIoctl;
  429.     pDev->pMixer = pMixer;
  431.     pSnd = (SND_FD *)pMixer;
  432.   }
  433.   else
  434.   {
  435.     errno = ENODEV;
  436.     goto error;
  437.   }
  439. error:
  440.   semGive (pDev->devSem);
  441.   return pSnd ? (int)pSnd : ERROR;
  442. }
  444. static int sndClose (int devId)
  445. {
  446.   SND_FD *pSnd = (SND_FD *)devId;
  448.   return pSnd->fdClose (devId);
  449. }
  451. static int sndRead (int devId, char *buffer, int maxbytes)
  452. {
  453.   SND_FD *pSnd = (SND_FD *)devId;
  455.   return pSnd->fdRead (devId, buffer, maxbytes);
  456. }
  458. static int sndWrite (int devId, char *buffer, int nbytes)
  459. {
  460.   SND_FD *pSnd = (SND_FD *)devId;
  462.   return pSnd->fdWrite (devId, buffer, nbytes);
  463. }
  465. static int sndIoctl (int devId, int function, int arg)
  466. {
  467.   SND_FD *pSnd = (SND_FD *)devId;
  469.   return pSnd->fdIoctl (devId, function, arg);
  470. }
  472. /* DSP device methods.
  473.  */
  474. static int dspClose (int devId)
  475. {
  476.   DSP_FD *pDsp = (DSP_FD *)devId;
  477.   SND_DEV *pDev = pDsp->dev.pDev;
  479.   if (semTake (pDev->devSem, 30 * sysClkRateGet()))
  480.   {
  481.     errno = S_ioLib_DEVICE_ERROR;
  482.     return ERROR;
  483.   }
  485.   while (pDev->taskBusy) taskDelay (1);
  487.   pDev->pDsp = NULL;
  488.   free (pDsp);
  490.   semGive (pDev->devSem);
  492.   return OK;
  493. }
  495. static int dspRead (int devId, char *buffer, int maxbytes)
  496. {
  497.   errno = S_ioLib_UNKNOWN_REQUEST;
  498.   return ERROR;
  499. }
  501. static int dspWrite (int devId, char *buffer, int nbytes)
  502. {
  503.   DSP_FD *pDsp = (DSP_FD *)devId;
  504.   SND_DEV *pDev = pDsp->dev.pDev;
  505.   int bytesLeft = nbytes;
  506.   int x;
  507.   DMA_MSG mDma;
  509.   /**
  510.     Convert from uLaw to PCM if needed -- note, we only
  511.     support 8-bit uLaw
  512.   */
  513.   if (pDsp->info.uLaw) {
  514.       for (x=0; x<nbytes; x++) {
  515.           buffer[x] = ulaw_dsp[((unsigned char)buffer[x])];
  516.       } /* endfor */
  517.   } /* endfor */
  519.   /* Check if we were recording.  If so, wait till all is clear.
  520.    */
  521.   if (pDev->pDsp->dmaDirection != O_WRONLY)
  522.     while (pDev->taskBusy) taskDelay (1);
  524.   while (bytesLeft > 0)
  525.   {
  526.     mDma.buffer    = getDmaBuffer (pDev);
  527.     mDma.length    = bytesLeft > MAX_DMA_SIZE ? MAX_DMA_SIZE : bytesLeft;
  528.     mDma.direction = O_WRONLY;
  530.     memcpy (mDma.buffer, buffer, mDma.length);
  531.     if (mDma.length<MAX_DMA_SIZE) {
  532.         bzero(mDma.buffer+mDma.length,MAX_DMA_SIZE-mDma.length);
  533.     } /* endif */
  536.     msgQSend (pDev->dmaQ, (char *)&mDma, sizeof (mDma),
  537.       WAIT_FOREVER, MSG_PRI_NORMAL);
  539.     buffer    += mDma.length;
  540.     bytesLeft -= mDma.length;
  541.   }
  543.   return nbytes - bytesLeft;
  544. }
  546. static int dspIoctl (int devId, int function, int arg)
  547. {
  548.   DSP_FD *pDsp = (DSP_FD *)devId;
  549.   SND_DEV *pDev = pDsp->dev.pDev;
  550.   union arg_union
  551.   {
  552.     int i;
  553.     long l;
  554.     int *pInt;
  555.     long *pLong;
  556.     snd_info_t *pInfo;
  557.   } u_arg;
  558.   
  559.   u_arg.i = arg;
  561.   switch (function)
  562.   {
  563.     case SNDCTL_DSP_SYNC:
  564.       while (pDev->taskBusy) taskDelay (1);
  565.       return OK;
  567.     case SNDCTL_DSP_GETBLKSIZE:
  568.       *u_arg.pInt = MAX_DMA_SIZE;
  569.       return OK;
  571.     case SNDCTL_DSP_SPEED:
  572.       {
  573. int i = *u_arg.pLong;
  575. if (i < RATE_MIN) i = RATE_MIN;
  576. if (i > RATE_MAX) i = RATE_MAX;
  577. while (pDev->taskBusy) taskDelay (1);
  578. pDsp->info.rate = i;
  579. return OK;
  580.       }
  582.     case SNDCTL_DSP_STEREO:
  583.       while (pDev->taskBusy) taskDelay (1);
  584.       pDsp->info.stereo = *u_arg.pInt;
  585.       return OK;
  587.     case SNDCTL_DSP_SAMPLESIZE:
  588.       if (*u_arg.pInt == 8 || *u_arg.pInt == 16)
  589.       {
  590. while (pDev->taskBusy) taskDelay (1);
  591. pDsp->info.sampleSize = *u_arg.pInt;
  592. return OK;
  593.       }
  594.       break;
  595.     case SNDCTL_DSP_SETFORMAT:
  596.       pDsp->info.uLaw = *u_arg.pInt;
  597.       return OK;
  598.       break;
  599.     case SNDCTL_GET_INFO:
  600.       *u_arg.pInfo = pDsp->info;
  601.       return OK;
  603.     case SNDCTL_SET_INFO:
  604.       while (pDev->taskBusy) taskDelay (1);
  605.       pDsp->info = *u_arg.pInfo;
  606.       return OK;
  607.   }
  608.   errno = S_ioLib_UNKNOWN_REQUEST;
  609.   return ERROR;
  610. }
  612. /* Mixer device methods.
  613.  */
  614. static int mixerClose (int devId)
  615. {
  616.   MIXER_FD *pMixer = (MIXER_FD *)devId;
  617.   SND_DEV *pDev = pMixer->dev.pDev;
  619.   if (semTake (pDev->devSem, 30 * sysClkRateGet()))
  620.   {
  621.     errno = S_ioLib_DEVICE_ERROR;
  622.     return ERROR;
  623.   }
  625.   pDev->pMixer = NULL;
  626.   free (pMixer);
  628.   semGive (pDev->devSem);
  630.   return OK;
  631. }
  633. static int mixerRead (int devId, char *buffer, int maxbytes)
  634. {
  635.   errno = S_ioLib_DEVICE_ERROR;
  636.   return ERROR;
  637. }
  639. static int mixerWrite (int devId, char *buffer, int nbytes)
  640. {
  641.   errno = S_ioLib_DEVICE_ERROR;
  642.   return ERROR;
  643. }
  645. static int mixerIoctl (int devId, int function, int arg)
  646. {
  647.   MIXER_FD *pMixer = (MIXER_FD *)devId;
  648.   union arg_union
  649.   {
  650.     int i;
  651.     long l;
  652.     int *pInt;
  653.     long *pLong;
  654.     snd_info_t *pInfo;
  655.   } u_arg;
  656.   
  657.   u_arg.i = arg;
  659.   switch (function)
  660.   {
  661.     case SNDCTL_SET_VOLUME:
  662.       {
  663. int volume = *u_arg.pLong;
  664. mixer_set_level (pMixer->dev.pDev, "master", volume);
  665. return OK;
  666.       }
  668.     case SNDCTL_GET_VOLUME:
  669.       {
  670. *u_arg.pLong = mixer_get_level (pMixer->dev.pDev, "master");
  672. return OK;
  673.       }
  674.   }
  675.   errno = S_ioLib_UNKNOWN_REQUEST;
  676.   return ERROR;
  677. }
  680. static void processOutput (SND_DEV *pDev, DMA_MSG mDma)
  681. {
  682.   int dmaChannel = IS_16BITS(pDev->pDsp) ? pDev->dma16 : pDev->dma8;
  684.   if (pDev->pDsp->dmaDirection != O_WRONLY ||
  685.       pDev->pDsp->dmaChannel   != dmaChannel)
  686.   {
  687.     pDev->dmaAuto = 0;
  689.     pDev->pDsp->dmaDirection = mDma.direction;
  690.     pDev->pDsp->dmaChannel   = dmaChannel;
  691.   }
  693.   if (pDev->dmaAuto)
  694.   {
  695.     if (mDma.length != MAX_DMA_SIZE)
  696.     {
  697.       /* If this was the interrupt from the middle of the block,
  698.        * then wait around for the next one.
  699.        */
  700.       if (pDev->dmaAuto)
  701.       {
  702. pDev->dmaAuto = 0;
  704. if (semTake (pDev->intSem, 5 * sysClkRateGet()))
  705.   logMsg ("SB16: Interrupt timeoutn", 0, 0, 0, 0, 0, 0);
  707. freeDmaBuffer (pDev);
  708.       }
  710.       /* We are done with auto init mode.
  711.        */
  712.       dsp_command (pDev, IS_16BITS(pDev->pDsp) ?
  713.    SB_DSP_DMA16_EXIT : SB_DSP_DMA8_EXIT);
  715.       /* Setup a one-shot.
  716.        */
  717.       dmaSetup (DMA_MODE_SINGLE | DMA_MODE_WRITE,
  718. mDma.buffer, mDma.length, dmaChannel);
  720.       /* Send out this block.
  721.        */
  722.       dsp_output (pDev->pDsp, mDma.length);
  723.     }
  724.   }
  725.   else
  726.   {
  727.     dsp_command (pDev, SB_DSP_DMA8_OFF);
  728.     dsp_command (pDev, SB_DSP_DMA16_OFF);
  730.     if (mDma.buffer == snd_dmaBuffer && mDma.length == MAX_DMA_SIZE)
  731.     {
  732.       pDev->dmaAuto = 2;
  734.       dmaSetup (DMA_MODE_SINGLE | DMA_MODE_WRITE | DMA_MODE_AUTO_ENABLE,
  735. snd_dmaBuffer, MAX_DMA_MSGS * MAX_DMA_SIZE, dmaChannel);
  737.       /* Check for the next buffer available when half the buffer
  738.        * has been transferred.
  739.        */
  740.       mDma.length >>= 1;
  741.     }
  742.     else
  743.     {
  744.       dmaSetup (DMA_MODE_SINGLE | DMA_MODE_WRITE,
  745. mDma.buffer, mDma.length, dmaChannel);
  746.     }
  748.     /* Send out this block.
  749.      */
  750.     dsp_output (pDev->pDsp, mDma.length);
  751.   }
  752. }
  754. /* Interrupt handler and Helper task
  755.  */
  756. static void dspInterrupt (SND_DEV *pDev)
  757. {
  758.   int status;
  760.   sysOutByte (SBP(pDev, MIXER_ADDR), SB_MIXER_IRQ_STAT);
  761.   status = sysInByte (SBP(pDev, MIXER_DATA));
  763.   /* 8bit DMA interrupt
  764.    */
  765.   if (status & 1)
  766.   {
  767.     dsp_ack_8bit (pDev);
  768.     semGive (pDev->intSem);
  769.   }
  771.   /* 16bit DMA interrupt
  772.    */
  773.   if (status & 2)
  774.   {
  775.     dsp_ack_16bit (pDev);
  776.     semGive (pDev->intSem);
  777.   }
  778. }
  780. static int dspHelperTask (SND_DEV *pDev)
  781. {
  782.   DMA_MSG mDma;
  784.   while (1)
  785.   {
  786.     pDev->taskBusy = pDev->dmaAuto = 0;
  788.     dsp_command (pDev, SB_DSP_SPEAKER_OFF);
  789.     dsp_command (pDev, SB_DSP_DMA8_OFF);
  790.     dsp_command (pDev, SB_DSP_DMA16_OFF);
  792.     if (msgQReceive (pDev->dmaQ, (char *)&mDma,
  793.      sizeof (mDma), WAIT_FOREVER) != sizeof (mDma))
  794.       return 0;
  796.     pDev->taskBusy = 1;
  797.     dsp_command (pDev, SB_DSP_SPEAKER_ON);
  799.     do
  800.     {
  801.       switch (mDma.direction)
  802.       {
  803. case O_WRONLY:
  804.   processOutput (pDev, mDma);
  805.   break;
  806. case O_RDONLY:
  807.   break;
  808.       }
  810.       /* wait for a DMA interrupt
  811.        */
  812.       if (semTake (pDev->intSem, 5 * sysClkRateGet()))
  813. logMsg ("SB16: Interrupt timeoutn", 0, 0, 0, 0, 0, 0);
  815.       if (pDev->dmaAuto)
  816.       {
  817. /* We can do this, because we know the stream will be
  818.  * non-contiguous if any properties change (rate, direction, etc).
  819.  */
  820. while (pDev->dmaAuto)
  821. {
  822.   pDev->dmaAuto--;
  824.   if (pDev->dmaAuto)
  825.   {
  826.     if (msgQReceive (pDev->dmaQ, (char *)&mDma,
  827.      sizeof (mDma), NO_WAIT) != sizeof (mDma))
  828.     {
  829.       pDev->dmaAuto = 0;
  830.     }
  831.   }
  832.   else
  833.   {
  834.     /* Great, we can keep going with 2 more interrupts to follow.
  835.      */
  836.     pDev->dmaAuto = 2;
  838.     freeDmaBuffer (pDev);
  839.   }
  841.   /* wait for the next DMA interrupt
  842.    */
  843.   if (semTake (pDev->intSem, 5 * sysClkRateGet()))
  844.     logMsg ("SB16: Interrupt timeoutn", 0, 0, 0, 0, 0, 0);
  845. }
  847. /* We can't do any more DMA continuously.
  848.  */
  849. dsp_command (pDev, IS_16BITS(pDev->pDsp) ?
  850.      SB_DSP_DMA16_EXIT : SB_DSP_DMA8_EXIT);
  851.       }
  853.       freeDmaBuffer (pDev);
  855.     } while (msgQReceive (pDev->dmaQ, (char *)&mDma,
  856.   sizeof (mDma), NO_WAIT) == sizeof (mDma));
  857.   }
  858. }
  861. /* DMA buffer management routines
  862.  */
  864. /* DMA buffers are never grabbed by the interrupt routine
  865.  */
  866. static int createDmaBuffer (void)
  867. {
  868. /*   snd_dmaBuffer = sysDmaMalloc (MAX_DMA_MSGS * MAX_DMA_SIZE); */
  870.   bzero (snd_dmaBuffer, MAX_DMA_MSGS * MAX_DMA_SIZE);
  872.   return snd_dmaBuffer ? OK : ERROR;
  873. }
  875. static char *getDmaBuffer (SND_DEV *pDev)
  876. {
  877.   char *dmaBuffer;
  879.   semTake (pDev->bufSem, WAIT_FOREVER);
  881.   semTake (pDev->devSem, WAIT_FOREVER);
  882.   dmaBuffer = snd_dmaBuffer + pDev->dmaIndex * MAX_DMA_SIZE;
  883.   pDev->dmaIndex = (pDev->dmaIndex + 1) % MAX_DMA_MSGS;
  884.   semGive (pDev->devSem);
  886.   return dmaBuffer;
  887. }
  889. /* DMA buffers are always freed by the interrupt routine
  890.  */
  891. static void freeDmaBuffer (SND_DEV *pDev)
  892. {
  893.   semGive (pDev->bufSem);
  894. }
  897. /* Low level register access routines.
  898.  */
  899. static int dsp_init (SND_DEV *pDev)
  900. {
  901.   int version;
  903.   /* Initialization the DSP
  904.    */
  905.   if (dsp_reset (pDev) < 0)
  906.   {
  907.     logMsg ("SB16: [0x%x] reset failed... 0x%xn",
  908.     pDev->port, sysInByte (SBP(pDev, READ)), 0, 0, 0, 0);
  909.     return -ENODEV;
  910.   }
  912.   /* Get the version number of the DSP
  913.    */
  914.   if ((version = dsp_version (pDev)) < 0)
  915.   {
  916.     logMsg ("SB16: [0x%x] get version failed... 0x%xn",
  917.     pDev->port, sysInByte (SBP(pDev, READ)), 0, 0, 0, 0);
  918.     return -ENODEV;
  919.   }
  921.   pDev->version = version;
  923.   switch (pDev->version >> 8)
  924.   {
  925.     case 1: case 2: case 3:
  926.       logMsg ("SB16: [0x%x] DSP chip version %i.%i is not supported"
  927.       " with the SB16 coden", pDev->port, pDev->version >> 8,
  928.       pDev->version & 0xff, 0, 0, 0);
  929.       return -ENODEV;
  930.     case 4:
  931.       break;
  932.     default:
  933.       logMsg ("SB16: [0x%x] unknown DSP chip version %i.%in",
  934.       pDev->port, pDev->version >> 8, pDev->version & 0xff, 0, 0, 0);
  935.       return -ENODEV;
  936.   }
  938.   dsp_command (pDev, SB_DSP_SPEAKER_OFF);
  940.   opl3_init (pDev);
  942.   return 0;
  943. }
  945. static int dsp_version (SND_DEV *pDev)
  946. {
  947.   int i;
  948.   unsigned int result = -1;
  950.   sysIntDisablePIC (pDev->irq);
  951.   dsp_command (pDev, SB_DSP_GET_VERSION);
  952.   for (i = 100000; i; i--)
  953.     if (sysInByte (SBP(pDev, DATA_AVAIL)) & 0x80)
  954.     {
  955.       result = (short) sysInByte (SBP(pDev, READ)) << 8;
  956.       break;
  957.     }
  958.   for (i = 100000; i; i--)
  959.     if (sysInByte (SBP(pDev, DATA_AVAIL)) & 0x80)
  960.     {
  961.       result |= (short) sysInByte (SBP(pDev, READ));
  962.       break;
  963.     }
  964.   sysIntEnablePIC (pDev->irq);
  965.   return result;
  966. }
  968. static int dsp_reset (SND_DEV *pDev)
  969. {
  970.   int i;
  972.   sysIntDisablePIC (pDev->irq);
  973.   sysOutByte (SBP(pDev, RESET), 1);
  974.   sysDelay ();
  975.   sysOutByte (SBP(pDev, RESET), 0);
  976.   sysDelay ();
  977.   for (i = 0; i < 1000 && !(sysInByte (SBP(pDev, DATA_AVAIL)) & 0x80); i++);
  978.   i = sysInByte (SBP(pDev, READ));
  979.   sysIntEnablePIC (pDev->irq);
  980.   if (i == 0xaa) return 0;
  982.   return -ENODEV;
  983. }
  986. /* OPL3 functions...
  987.  */
  988. static int opl3_init (SND_DEV *pDev)
  989. {
  990.   int i;
  992.   /* Reset opl3 timers 1 and 2
  993.    */
  994.   opl3_command (SBP(pDev, OPL3_LEFT), TIMER_CONTROL_REGISTER,
  995. TIMER1_MASK | TIMER2_MASK);
  997.   /* Reset the IRQ of the FM chip
  998.    */
  999.   opl3_command (SBP(pDev, OPL3_LEFT), TIMER_CONTROL_REGISTER, IRQ_RESET);
  1001.   i = sysInByte (SBP(pDev, OPL3_LEFT));
  1003.   if (i == 0x00 || i == 0x0f)
  1004.   {
  1005.     opl3_command (SBP(pDev, OPL3_RIGHT), OPL3_MODE_REGISTER, 0x00);
  1006.     opl3_command (SBP(pDev, OPL3_RIGHT), OPL3_MODE_REGISTER, OPL3_ENABLE);
  1007.     opl3_command (SBP(pDev, OPL3_RIGHT), CONNECTION_SELECT_REGISTER, 0x00);
  1009.     for (i=0; i<9; i++)
  1010.       opl3_command (SBP(pDev, OPL3_LEFT), KEYON_BLOCK, 0);
  1012.     opl3_command (SBP(pDev, OPL3_LEFT), TEST_REGISTER, ENABLE_WAVE_SELECT);
  1013.     opl3_command (SBP(pDev, OPL3_LEFT), PERCUSSION_REGISTER, 0x00);
  1015.     opl3_command (SBP(pDev, OPL3_RIGHT), OPL3_MODE_REGISTER, 0x00);
  1016.   }
  1017.   else
  1018.     logMsg ("SB16: [0x%x] OPL3 detect failed... 0x%xn",
  1019.     pDev->port, i, 0, 0, 0, 0);
  1021.   return 0;
  1022. }
  1024. /* Mixer stuff.  Really belongs in it's own device....
  1025.  */
  1026. static int mixer_init (SND_DEV *pDev)
  1027. {
  1028.   int irq;
  1029.   int mpu;
  1031.   switch (pDev->irq)
  1032.   {
  1033.     case 2: case 9: irq = 0x01; break;
  1034.     case 5:         irq = 0x02; break;
  1035.     case 7:         irq = 0x04; break;
  1036.     case 10:        irq = 0x08; break;
  1037.     default:        irq = 0x00;
  1038.   }
  1040.   mixer_write (pDev, 0x0, 0x0); /* reset mixer */
  1041.   sysDelay ();
  1043.   mpu = mixer_read (pDev, SB_MIXER_MPU_NR) & ~0x06;
  1045.   mixer_write (pDev, SB_MIXER_IRQ_NR, irq);
  1046.   mixer_write (pDev, SB_MIXER_DMA_NR, (1 << pDev->dma16) | (1 << pDev->dma8));
  1048.   mixer_write (pDev, SB_MIXER_MPU_NR, mpu & 0x02); /* disable mpu */
  1050.   /* Turn on all inputs.
  1051.    */
  1052.   mixer_write (pDev, SB_MIXER_OUTPUT_SW, 0x1f);
  1054.   /* Set volumes to reasonable values for now...
  1055.    */
  1056.   mixer_set_level (pDev, "master", 90 << 8 | 90);
  1057.   mixer_set_level (pDev, "pcm", 90 << 8 | 90);
  1059.   mixer_set_level (pDev, "speaker", 0);
  1060.   mixer_set_level (pDev, "ogain", 0);
  1061.   mixer_set_level (pDev, "igain", 0);
  1063.   mixer_set_level (pDev, "treble", 50);
  1064.   mixer_set_level (pDev, "bass",   50);
  1066.   return 0;
  1067. }
  1071. /**
  1072. $Log: sb16drv.c,v $
  1073. Revision 1.5  1999/12/18 00:01:38  steveh
  1074. Corrected loop bug for audio on small buffers.
  1075. Connected up fwd,back and stop buttons.
  1076. Attempted to connect up logic to display link that mouse is over,
  1077. but api seems to not work for this.
  1079. Revision 1.4  1999/12/03 06:52:09  steveh
  1080. Created new IOCTL to set 8-bit uLaw format in SB driver.
  1081. Moved uLaw code from java to driver.
  1083. */