source: sbliveos2/trunk/drv16/mpu401.cpp@ 143

/* $Id: mpu401.cpp 142 2000-04-23 14:55:46Z ktk $ */

/* SCCSID = %W% %E% */
/****************************************************************************
 *                                                                          *
 * Copyright (c) IBM Corporation 1994 - 1997.                               *
 *                                                                          *
 * The following IBM OS/2 source code is provided to you solely for the     *
 * the purpose of assisting you in your development of OS/2 device drivers. *
 * You may use this code in accordance with the IBM License Agreement       *
 * provided in the IBM Device Driver Source Kit for OS/2.                   *
 *                                                                          *
 ****************************************************************************/
/**@internal %W%
 *  MPU_401 object implementation.
 * @version %I%
 * @context
 *  Unless otherwise noted, all interfaces are Ring-0, 16-bit, kernel stack.
 * @notes
 * @history
 */

extern "C" {               // 16-bit header files are not C++ aware
#define INCL_NOPMAPI
#define INCL_DOSMISC
#include <os2.h>
}
#include <os2medef.h>                  // DATATYPE_MIDI
#include <include.h>                   // cli, sti, inp, outp
#include <string.h>                    // strcpy(), strcat()
#include "sizedefs.h"                  //### NUM_DEVICES, MAX_MPU401
#include "..\midi\midi_idc.h"          // RTMIDI i/f
#include "iodelay.h"
#include "malloc.h"
#include "mpu401.hpp"                  // Object definition.
#include "timer.hpp"                   // Object definition.
#include "stream.hpp"                  // Prereq to includeing midistrm.h
#include "midistrm.hpp"                // Object definition.

#include "parse.h"


/* Constructor. */

MPU_401::MPU_401(TIMER* pTimer ) :
   MIDIAUDIO ( AUDIOHW_MPU401_PLAY, pTimer )
{
   static char szName[] = "SBLive #";  // Instance name for RTMIDI.  A number will be appended.
   static char szSuffix[] = "0";       // Printable char that is appended to szName.

   usDataPort = 0x300;
   usStatPort = 0x300 + 1;

   // RTMIDI (MIDI.SYS) related stuff
   ++szSuffix[0];                      // Bump number in instance name.
   strcpy( szRTMIDI_Name, szName );    // Setup instance name.
   strcat( szRTMIDI_Name, szSuffix );  // Append ASCII number to instance name.
   ulRTMIDI_Caps = MIDICAPSA_INPUT;    // Set RTMIDI caps.
   // When we have an IRQ and a send capability, add next line.
   // ulCapabilities |= MIDICAPSA_OUTPUT;
}


#define TIMEOUT   60000

unsigned MPUcommand(USHORT usDataPort, BYTE b)
/* Returns 0 when command is properly accepted by the specified port;
 * Returns 1 - 4 to indicate various timeout conditions.
 */
{
   unsigned i;
   const usStatPort = usDataPort + 1;

   i=1000;
   while (--i) {
      if (inp(usStatPort) & DSR) break;
      inp(usDataPort);
      iodelay(1);                      // Delay >= 0.5 uSec
   }
   if ( !i ) {                         // >500 millisecond wait?
      return 4;
   }

   for (i=0; i<TIMEOUT; i++) {
      if (!(inp(usStatPort) & DRR)) {  // wait until it's ready
         iodelay(1);                   // just to be safe
         outp(usStatPort,b);
         iodelay(1);                   // just to be safe
         for (i=0; i<TIMEOUT; i++) {
            if (!(inp(usStatPort) & DSR)) {
               iodelay(1);             // just to be safe
               i=inp(usDataPort);
               if (i == 0xFE)
                  return 0;
               else {
                  return 3;
               }
            }
            iodelay(1);
         }
         if (b == 0xFF) {
            return 0;
         }
         else {
            return 1;
         }
      }
      iodelay(1);
   }

   return 2;
}

virtual void MPU_401::noteOff( BYTE mchan, BYTE note, BYTE velocity )
{
   writeByte( (BYTE) 0x80 | mchan );
   writeByte( note );
   writeByte( velocity );
}

virtual void MPU_401::noteOn( BYTE mchan, BYTE note, BYTE velocity )
{
   writeByte( (BYTE) 0x90 | mchan );
   writeByte( note );
   writeByte( velocity );
}

virtual void MPU_401::polyphonicPressure( BYTE mchan, BYTE note, BYTE value )
{
   writeByte( (BYTE) 0xA0 | mchan );
   writeByte( note );
   writeByte( value );
}

virtual void MPU_401::controlChange( BYTE mchan, BYTE control_number, BYTE value )
{
   writeByte( (BYTE) 0xB0 | mchan );
   writeByte( control_number );
   writeByte( value );
}

virtual void MPU_401::programChange( BYTE mchan, BYTE program_number )
{
   writeByte( (BYTE) 0xC0 | mchan );
   writeByte( program_number );
}

virtual void MPU_401::channelPressure( BYTE mchan, BYTE value )
{
   writeByte( (BYTE) 0xD0 | mchan );
   writeByte( value );
}

virtual void MPU_401::pitchBend( BYTE mchan, BYTE value_lsb, BYTE value_msb )
{
   writeByte( (BYTE) 0xE0 | mchan );
   writeByte( value_lsb );
   writeByte( value_msb );
}


int MPU_401::_iAllNotesOff(void)
{
   for (int iChannel=0; iChannel<16; iChannel++) {
      writeByte((BYTE) (0xB0 + iChannel));    // channel mode
      writeByte(123);                         // all notes off
      writeByte(0);
   }

   return TRUE;
}


int MPU_401::writeByte(BYTE b)
{
   unsigned i;

   for (i=0; i<TIMEOUT; i++) {
      cli();
      if (!(inp(usStatPort) & DRR)) {
         outp(usDataPort, b);
         sti();
         return 1;
      }
      sti();
      iodelay(1);
   }
   return 0;
}

int MPU_401::readByte(void)
{
   unsigned i;

   for (i=0; i<TIMEOUT; i++) {
      cli();
      if (!(inp(usStatPort) & DSR)) {
         i=inp(usDataPort);
         sti();
         return i;
      }
      sti();
      iodelay(1);
   }
   return -1;
}

/* MPU_401::_iInitialize
 * ### Need cleanup return codes - currently they are not consistent
 * ### or documented.  Currently, returns 0 on SUCCESS.
 */
int MPU_401::_iInitialize(void)
{
   int rc;              // Return code from MPUcommand().

   rc = MPUcommand(usDataPort, 0xFF);
   if (rc == 0)
      rc = MPUcommand(usDataPort, 0x3F);

   return rc;
}

#pragma off (unreferenced)

int MPU_401::Reset(STREAM *stream)
{
    return 0;
}

int MPU_401::Start( STREAM *stream )
{
   BOOL rc;
   _iInitialize();

   // Start timer on 4 mSec interval.
   rc = getTimer()->Start();
   return rc;
}


int MPU_401::Stop(STREAM *stream)
{
   getTimer()->Stop();
   _iAllNotesOff();
   return 0;
}


int MPU_401::Pause(STREAM *stream)
{
   getTimer()->Pause();
   _iAllNotesOff();
   return 0;
}


int MPU_401::Resume(STREAM *stream)
{
   getTimer()->Resume();
   return 0;
}

USHORT MPU_401::RTMIDI_OpenReceive(void)
{
   //### Need to add serialization b/t MMPM/2 + RTMIDI, plus mult RTMIDI opens.

   USHORT us = _iInitialize();
   if (us)
      return MIDIERRA_HW_FAILED;
   else
      return 0;
}

USHORT MPU_401::RTMIDI_OpenSend(void)
{
   //### Need to add serialization b/t MMPM/2 + RTMIDI, plus mult RTMIDI opens.
   //### Send capability pending but not currently implemented.

   return MIDIERRA_HW_FAILED;
}

USHORT MPU_401::RTMIDI_CloseReceive(void)
{
   MPUcommand(usDataPort, 0xFF);
   return 0;
}

USHORT MPU_401::RTMIDI_CloseSend(void)
{
   MPUcommand(usDataPort, 0xFF);
   return 0;
}