extern char *in, *out;

void __irq spp_isr(void)
{
   while(SSPSR & (1<<2) )
     *in++ = SSPDR;

   while(SSPSR & (1<<1))
     SSPDR = *out++;
}

void ssp_start(char *inb, char *outb)
{
   int dummy;
   in = inb;
   out = outb+1;

     while(SSPSR & (1<<2) )
       dummy = SSPDR;

   SSPIMSC = 12;
   SSPDR = *outb;
  
}

  
while(SSPSR & (1<<1))
     SSPDR = *out++;

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
int init_SPI1( void )
{
    // Prescaler = 2 (Maximum Clock for Master)
    SSPCPSR_bit.CPSDVSR =  2;

    // Configure Pin Connect Block
    PINSEL1_bit.P0_17 = 0x2;       // SCK1
    PINSEL1_bit.P0_18 = 0x2;    // MISO1
    PINSEL1_bit.P0_19 = 0x2;    // MOSI1
    PINSEL1_bit.P0_20 = 0x2;    // SSEL1

    SSPCR0_bit.FRF    =   0;             // SPI Mode
    SSPCR0_bit.DSS    =  (8-1);         // 8bit Transfer
    SSPCR0_bit.CPOL =     1;             // Polarity
    SSPCR0_bit.CPHA =     1;            // Phase
    SSPCR0_bit.SCR     =  (4-1);        // Divider

    // Device selected as master
    SSPCR1_bit.MS      = 0;                // Master
    SSPCR1_bit.SSE  = 1;                // Global Enable

      for( int i = 0; i < 8; i++ )
      {    ulong dummy = SSPDR;         // Clear the RxFIFO
          dummy = dummy;
    }

    return( 0 );    // Ok
}


//---------------------------------------------------------------------------
BYTE ex_tx_buf[37] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29
,30,31,32,33,34,35,36};
BYTE ex_rx_buf[37];
#define EX_TX_BYTE {SSPDR = *tx_ptr++; nn--;}
#define EX_RX_BYTE *rx_ptr++ = SSPDR

// Experiment
//---------------------------------------------------------------------------
void SPI1_experiment( int size )
{
int nn=size;    
BYTE *tx_ptr = ex_tx_buf;
BYTE *rx_ptr = ex_rx_buf;
register BYTE stat;

    memset( rx_ptr, 0xFF, size );

//    ENTER_CRITICAL();
//    {
      
    do
    {  // Забиваем FIFO до упора - хорошо для прерывистого процесса
                 if( (stat = SSPSR) & SSPSR_TNF )
            EX_TX_BYTE;
        if( stat & SSPSR_RNE )    
            EX_RX_BYTE;
    }
    while( nn );
// Вычитывание хвостика FIFO
    do
    {   if( (stat = SSPSR) & SSPSR_RNE )    
            EX_RX_BYTE;
    }
    while( stat & SSPSR_BSY );
// И возможного последнего байта    
         if( SSPSR & SSPSR_RNE )    
        EX_RX_BYTE;

//    }
//    LEAVE_CRITICAL();
      
    bprintf_str( "RX:");
    for( nn = 0; nn<size; nn++ )
        bprintf_str( "%02X ", ex_rx_buf[nn] );        
    bprintf( "end" );          
                      
}

void
spi1_transfer(uint8_t *outb, uint8_t *inb, int n)
{
  int __dummy;
  uint8_t *in = inb;
  uint8_t *out = outb;

  FIO0SET = 1<<20; // just in case
  // clear spi1 input fifo
  while(SSPSR & (1<<2))
    __dummy = SSPDR;

  FIO0CLR = 1 << 20;
  // send one char
  SSPDR = *out++;
  n--;

  do
  {
    // hang until tr fifo is full
    while((SSPSR & (1<<1)) == 0);

    SSPDR = *out++;

    // check if rx data available
    if (SSPSR & (1<<2))
      *in++ = SSPDR;

  }
  while(--n);

  while(SSPSR & (1<<2))
    *in++ = SSPDR;

  // wait until busy...
  while(SSPSR & (1<<4));

  FIO0SET = 1<<20;
}