Subversion Repositories shark

/* Project:     HARTIK 3.0 Sound Library                        */
/* Description: Hard Real TIme Kernel for 8086 compatible       */
/* Author:      Luca Abeni                                      */
/* Date:        5/12/1997                                       */

/* File:        Sound.C                                         */
/* Revision:    3.0                                             */

/* added by Paolo */
#define SOUND_WCET 200

/* Sound generic interface */
#include <kernel/kern.h>

#include "blaster.h"
#include <drivers/sound.h>
#include <drivers/dma.h>

//extern struct proc_des proc_table[MAX_PROC];

extern struct sb_device sb_dev;
extern TASK proc_play();
extern TASK proc_sample();
extern TASK sb_proc();
extern void sb_handler(int n);
extern struct sound_buffer buff_des;
struct rawfuncs f_des;
struct dma_buff dma_des;

/*int sound_exc(int err)
{
    switch (err) {
        case SOUND_CARD_NOT_FOUND:
            cprintf("SOUND PANIC --> Sound card not found.\n");
            return 0;
        case SOUND_RAWFUN_NOT_SET:
            cprintf("Self-buffering OP error --> User function not set.\n");
            return 0;
        case SOUND_TICK_TOO_LARGE:
            cprintf("PIO mode OP error --> sys_tick too large.\n");
            return 0;
        case SOUND_ASYNCH_WAIT:
            cprintf("Asynchronous OP error --> Wait on asynch operation.\n");
            return 1;
        default :
            return 1;
    }
} */

/* Set the user's functions for self buffering */
void sound_setfun(int (*infun)(void *rawbuff), int (*outfun)(void *rawbuff))
{
    /* Should be NULL here! Luca: used -1 instead NULL */
    if (infun != NULL) {
        f_des.infun = infun;
        f_des.infunpresent = 1;
    }
    if(outfun != NULL) {
        f_des.outfun = outfun;
        f_des.outfunpresent = 1;
    }
}

/*
   This function is called by the sound card driver function when the card
   generate an interrupt during a self buffering input operation. The user's
   self buffering function is called by this function
*/
int selfinfun(struct dma_buff *b)
{
    int res;
   
    res = f_des.infun(&b->dma_buff[(b->dma_bufflen >> 1) * b->page]);
    b->page = !b->page;
    return res;
}

/*
   This function is called by the sound card driver function when the card
   generate an interrupt during a self buffering output operation. The user's
   self buffering function is called by this function
*/
int selfoutfun(struct dma_buff *b)
{
    int res;
   
    res = f_des.outfun(&b->dma_buff[(b->dma_bufflen >> 1) * b->page]);
    b->page = !b->page;
    return res;
}

/*
   Play a sample: this function calls the adeguate low-level playing function
   with the correct parameters

   the task model in the last parameter is used for the sb_player task.
   it must be a periodic task with a correct period. if not specified (NULL),
   a soft task is used instead.

   it returns 0 if all ok,
     EINVAL if the outfun isn't specified
     ESRCH if the sb_player can not be created
*/
int sound_play(BYTE *buff, DWORD sps, DWORD len, BYTE t, TASK_MODEL *m)
{
    double rate;
    PID p_pl;
//    WORD s1, p;

    /* Self Buffering?*/
    if (t & MYFUN) {
        /*Yes */
        if (f_des.outfunpresent != 0) {
            buff_des.fun = selfoutfun;
        }
        else
            return EINVAL;
    }
    else {
        /* No: set the standard double-buffering output function (module dma.c) */
        buff_des.fun = outfun;
    }
    /* set the operation parameters...*/
    buff_des.synch = !(t & SYNCH);
    dma_des.len = len;
    dma_des.p = buff;
    if (t & DMA_OP) {
        /* DMA op */
        sb_setrate(sps, OUT);
        /*
        if (t & DYNBUFF) {
            s1 = (sps / 1000) * ((t & PCM16) ? 2 : 1);
            p = ((dma_des.dma_bufflen >> 1) * 1000 ) / (sound_tick * s1);
            if(p < 1) {
                sb_dev.pwarning = 1;
                p = 1;
            } else sb_dev.pwarning = 0;
            / * Adjust the driver task's minimum interarrival time */ /*
            kern_cli();
            proc_table[p_sb].period = p;
            proc_table[p_sb].drel = p;
            kern_sti();
            sb_dev.period = p;
        } */
        if (!(t & NOBUFF)) {
            if (t & PCM16) sb_dma16buffop(OUT);
            else sb_dmabuffop(OUT);
        } else {
            /* Double buffering operation */
            buff_des.fun = dummyfun2;
            if (t & PCM16) sb_dma16op(OUT);
            else sb_dmaop(OUT);
        }
    } else {
        /* Non DMA op: create the playing process */
        SOFT_TASK_MODEL m_soft;
        if (!m) {
          rate = (999999 / sps) + 1;
          soft_task_default_model(m_soft);
          soft_task_def_system(m_soft);
          soft_task_def_nokill(m_soft);
          soft_task_def_period(m_soft,rate);
          soft_task_def_met(m_soft,rate);
          soft_task_def_wcet(m_soft,SOUND_WCET);
          m = (TASK_MODEL *)&m_soft;
        }
        p_pl = task_create("sb_Player",proc_play, &m, NULL);
        if (p_pl == NIL) {
            cprintf("Sound.c: Cannot create sb_Player\n");
            exit(1);
            return ESRCH;
        }
        task_activate(p_pl);
    }

    return 0;
}

/*
   Sample: this function calls the adeguate low-level sampling function
   with the correct parameters. It is similar to sound_play (see it for the
   comments

   the task model in the last parameter is used for the sb_player task.
   it must be a periodic task with a correct period. if not specified (NULL),
   a soft task is used instead.

   it returns 0 if all ok,
     EINVAL if the outfun isn't specified
     ESRCH if the sb_player can not be created
*/
int sound_sample(BYTE *buff, DWORD sps, DWORD len, BYTE t, TASK_MODEL *m)
{
    double rate;
    PID p_sample;
//    WORD s1, p;
//    MODEL m = BASE_MODEL;

    if (t & MYFUN) {
        if (f_des.infunpresent != 0) {
            buff_des.fun = selfinfun;
        }
        else
            return EINVAL;
    }
    else
        buff_des.fun = infun;

    buff_des.synch = !(t & SYNCH);
    dma_des.len = len;
    dma_des.p = buff;
    if (t & DMA_OP) {
        sb_setrate(sps, IN);
        /*
        if (t & DYNBUFF) {
            p_sb = task_pid("sb_EndDMA");
            s1 = (sps / 100) * ((t & PCM16) ? 2 : 1);
            p = ((dma_des.dma_bufflen >> 1) * 1000 ) / (sound_tick * s1);
            if(p < 1) {
                sb_dev.pwarning = 1;
                p = 1;
            } else sb_dev.pwarning = 0;
            kern_cli();
            proc_table[p_sb].period = p;
            proc_table[p_sb].drel = p;
            kern_sti();
            sb_dev.period = p;
        } */
        if (!(t & NOBUFF)) {
            if (t & PCM16) sb_dma16buffop(IN);
            else sb_dmabuffop(IN);
        } else {
            buff_des.fun = dummyfun2;
            if (t & PCM16) sb_dma16op(IN);
            else sb_dmaop(IN);
        }
    } else {
        /* Non DMA op: create the playing process */
        SOFT_TASK_MODEL m_soft;
        if (!m) {
          rate = (999999 / sps) + 1;
          soft_task_default_model(m_soft);
          soft_task_def_system(m_soft);
          soft_task_def_nokill(m_soft);
          soft_task_def_period(m_soft,rate);
          soft_task_def_met(m_soft,rate);
          soft_task_def_wcet(m_soft,SOUND_WCET);
          m = (TASK_MODEL *)&m_soft;
        }
        p_sample = task_create("sb_Sampler",proc_sample, &m, NULL);
        if (p_sample == NIL) {
            cprintf("Sound.c: Cannot create sb_Sampler\n");
            exit(1);
            return ESRCH;
        }
        task_activate(p_sample);
    }
    return 0;
}

/*
   Wait for the end of a synchronous sound op: it is implemented with a
   simple semaphore
   It returns  0 if all ok,
              -1 if no sinchronous operation was called before
*/
int sound_wait(void)
{
    if (buff_des.synch) {
        sem_wait(&buff_des.synchr);
        buff_des.synch = 0;
        return 0;
    }
    else
      return -1;
}


/* returns 0 if all ok,
   ENOSPC if a problem occurs when creating the semaphores structures
   ESRCH if the Enddma task cn not be created
*/
int sound_init(WORD rawbuffsize, TASK_MODEL *m)
{
    PID p_sb;
    int period;
    SOFT_TASK_MODEL m_soft;

    /* Semaphore for synchronous ops */
    if (sem_init(&buff_des.synchr,0,0))
      return ENOSPC;

    /* Init the card */
    sb_init();
    sbmixer_reset();
    sbmixer_setinput(0x01, ENABLE);
    sbmixer_setoutput(0x01, DISABLE);
    sbmixer_setmiclev(0x1F);
    sbmixer_setAGC(ENABLE);
    sbmixer_setingainlev(0);

    f_des.infun = 0;
    f_des.infunpresent = 0;
    f_des.outfun = 0;
    f_des.outfunpresent = 0;
    /* init the buffers for DMA ops */
    dma_getalignbuff(&dma_des, rawbuffsize);
    buff_des.sound_dma = &dma_des;

    if (!m) {
      period = (rawbuffsize * 1000000) / 48000;
      kern_printf("period=%d\n",period);
      soft_task_default_model(m_soft);
      soft_task_def_system(m_soft);
      soft_task_def_nokill(m_soft);
      soft_task_def_period(m_soft,period);
      soft_task_def_met(m_soft,SOUND_WCET);
      soft_task_def_wcet(m_soft,SOUND_WCET);
      soft_task_def_aperiodic(m_soft);
      m = (TASK_MODEL *)&m_soft;
    }

    /* create the driver process and set it and the Fast Handler */
    p_sb = task_create("sb_EndDMA", sb_proc, m, NULL);
    if (p_sb == NIL) {
        cprintf("Sound.c: Cannot create sb_EndDMA\n");
        cprintf("errno=%d\n",errno);
        exit(1);
        return ESRCH;
    }
    //sb_dev.period = period;
    handler_set(sb_dev.IntLine, sb_handler, p_sb, FALSE);

    return 0;
}

/* Obvious... */
void sound_info(void)
{
    cprintf("Hartik Sound lib [V 3.2]:\n");
    cprintf("Sound Blaster 16 or clone found:\n");
    sb_show();
}

/*
   This function is called by the driver process on the last transfert of an
   operation
*/
int dummyfun1(struct dma_buff *d)
{
    buff_des.fun = dummyfun2;
    return 0;
}

/*
   This function is called by the driver process when the next transfert
   will be the last of the current operation
*/
int dummyfun2(struct dma_buff *d)
{
    if (buff_des.synch) sem_post(&buff_des.synchr);
    sb_stopdsp(8);
    sb_stopdsp(16);
    dma_stop(sb_dev.DMA8Channel);
    dma16_stop(sb_dev.DMA16Channel);
    return 0;
}

/* Obvious... */
void sound_stop(void)
{
    if (!buff_des.synch) {
        sb_stopdsp(8);
        sb_stopdsp(16);
        dma_stop(sb_dev.DMA8Channel);
        dma16_stop(sb_dev.DMA16Channel);
    }
}