#define SSC_A5_LEN 6 /*синхробайты начала 0xA5*/
#define SSC_CMD_LEN 2 /*код команды*/
#define SSC_SERVICE_LEN 32 /*сервисные данные*/
#define SSC_DATA_LEN 512
#define SSC_CRC_LEN 2
#define SSC_E6_LEN 6 /*синхробайты конца 0xE6*/
#define SSC_HEADER_LEN (SSC_A5_LEN+SSC_CMD_LEN+SSC_SERVICE_LEN)
#define SSC_TAIL_LEN (2/*CRC*/+SSC_E6_LEN)
#define SSC_BLOCK_LEN (SSC_HEADER_LEN + SSC_DATA_LEN + SSC_TAIL_LEN)
#define SSC_BIT_PER_FRAME 32
  
#define FillSscHeader(buf) memset(buf, 0xA5, SSC_A5_LEN)
#define FillSscFooter(buf) memset(&(buf[SSC_BLOCK_LEN-SSC_E6_LEN]), 0xE6, SSC_E6_LEN)
  
//биты tSSC.flags
#define SSCRX_HANDLER_UPDATED (1 << 0) //обновлен хендлер приема
#define SSCTX_HANDLER_UPDATED (1 << 1) //обновлен хендлер передачи
#define SSCTX_PACKET_UPDATED (1 << 2) //обновился буфер передачи. Это значит, что перед запуском передачи
                                              // обработчик ISR должен обновить данные в буфере PDC (DMA).
#define SSCRX_CANDATA (1 << 3) //есть данные для CAN
#define SSCRX_NEWCANDATA (1 << 4) //данные для CAN пришли только что
#define SSCTX_UPDATE_DSP_RQ (1 << 5) //сигнал вызвать TXhandler, чтобы подготовить новые данные 
                                              // передачи для DSP. Флаг устанавливается в любом месте
                                              // основной программы, а обрабатывается и сбрасывается 
                                              // в DSPhandler (цикл main).
#define SSCTX_DSP_PAUSE (1 << 6) //пауза для работы DSP
#define SSCTX_COMPLETED (1 << 7) //передача полностью завершена
  
typedef __packed struct _SSC
{
   u8 pdcbufRX[SSC_BLOCK_LEN]; // буфер PDC (DMA) приема
   u8 pdcbufTX[SSC_BLOCK_LEN]; // буфер PDC (DMA) передачи
   u8 bufRX   [SSC_BLOCK_LEN-(SSC_A5_LEN+SSC_E6_LEN)]; // выходной буфер приема
   u8 bufTX   [SSC_BLOCK_LEN-(SSC_A5_LEN+SSC_E6_LEN)]; // выходной буфер передачи
   void (*RXhandler)(u8 idxSSCrx);
   void (*TXhandler)(void);
   u8 tail_detected;           // синхробайты конца 0xE6 0xE6 0xE6 0xE6 0xE6 0xE6 прошли
   u8 txflags;                   // флаги для передачи
   u8 rxflags;                   // флаги для приема
   u32 rectimeout;
   int reciv_shift;
   tERRSSCcounters errcnt;
   tSSCcounters cnt;
} tSSC;
  
typedef __packed struct _ERRSSCcounters
{
   u32 missheader;          // счетчик не найденных заголовков
   u32 crc;                 // счетчик ошибок CRC
   u32 timeout;             // ошибка таймаута
}tERRSSCcounters;
  
typedef __packed struct _SSCcounters
{
   u32 tx;                  // сколько было передач
   u32 rx;                  // сколько было успешных приемов
   u32 intdsp;
   u32 rxOK;                // сколько было успешных приемов
}tSSCcounters;
  
typedef __packed struct _SSC
{
   u8 pdcbufRX[SSC_BLOCK_LEN]; // буфер PDC (DMA) приема
   u8 pdcbufTX[SSC_BLOCK_LEN]; // буфер PDC (DMA) передачи
   u8 bufRX   [SSC_BLOCK_LEN-(SSC_A5_LEN+SSC_E6_LEN)]; // выходной буфер приема
   u8 bufTX   [SSC_BLOCK_LEN-(SSC_A5_LEN+SSC_E6_LEN)]; // выходной буфер передачи
   void (*RXhandler)(u8 idxSSCrx);
   void (*TXhandler)(void);
   u8 tail_detected;           // синхробайты конца 0xE6 0xE6 0xE6 0xE6 0xE6 0xE6 прошли
   u8 txflags;                   // флаги для передачи
   u8 rxflags;                   // флаги для приема
   u32 rectimeout;
   int reciv_shift;
   tERRSSCcounters errcnt;
   tSSCcounters cnt;
} tSSC;
  
//общая схема передаваемого блока, всего 6+546+6 = 558 байт
typedef __packed struct _TRawBlock
{
    //u8 A5[6]; //0xA5 0xA5 0xA5 0xA5 0xA5 0xA5
    u16 cmd;        //код команды
    u8 serv[32];    //сервисные данные, которые зависят от команды
    u8 data[512];   //512 байт полезных данных
    u16 CRC16;      //2 байта CRC
    //u8 E6[6]; //0xE6 0xE6 0xE6 0xE6 0xE6 0xE6 синхробайты конца
}TRawBlock;
  
extern tSSC vSSC;  //служебные данные порта SSC

tSSC vSSC;  //служебные данные порта SSC

void FillSscHeader (u8 *buf)
{
   memset(buf, 0xA5, SSC_A5_LEN);
}

void FillSscFooter (u8 *buf)
{
   //считаем CRC
   ((TRawBlock*)buf)->CRC16 = CRC_START_VAL;
    AddCRC16(&(buf[6]), 2+32+512, (u16*)&((TRawBlock*)buf)->CRC16);
   //заполняем хвост - шесть байт 0xE6
   memset(&(buf[SSC_BLOCK_LEN-SSC_E6_LEN]), 0xE6, SSC_E6_LEN);
}

//процедура запускает отправку буфера vSSC.pdcbufTX
void SSCtransmit (void)
{
   u16 donetimeout = 0;
   FillSscHeader(vSSC.pdcbufTX);
   FillSscFooter(vSSC.pdcbufTX);
   //Запустим передачу.
   while (!vSSC.txdone)
   {
      donetimeout++;
      if (donetimeout > 20000)
         vSSC.txdone = true;
   }
    
   //даем сигнал для DSP (сбрасываем в 0)
   PIO_Configure(&outINTarm, 1);
   vSSC.txdone = false;
#if (SSC_BIT_PER_FRAME < = 8)
   SSC_WriteBuffer(AT91C_BASE_SSC, (void *) vSSC.pdcbufTX, SSC_BLOCK_LEN);
#elif (SSC_BIT_PER_FRAME < = 16)
   SSC_WriteBuffer(AT91C_BASE_SSC, (void *) vSSC.pdcbufTX, SSC_BLOCK_LEN/2);
#elif (SSC_BIT_PER_FRAME < = 32)
   SSC_WriteBuffer(AT91C_BASE_SSC, (void *) vSSC.pdcbufTX, SSC_BLOCK_LEN/4);
#else
#error "SSC_BIT_PER_FRAME invalid"
#endif
   //разрешим прерывание по окончанию передачи
   SSC_EnableInterrupts(AT91C_BASE_SSC, AT91C_SSC_TXBUFE);
   //разрешаем передатчик
   SSC_EnableTransmitter(AT91C_BASE_SSC);
   vSSC.cnt.tx++;
}

void setSSChandlers (void rx(void), void tx(void))
{
   vSSC.RXhandler = rx;
   vSSC.TXhandler = tx;
}

void ConfigureSSC (u32 baudrate)
{
    //конфигурируем прерывание от сигнала передачи от DSP
    PIO_EnableIt(&inINTdsp);
    //сбрасываем переменные SSC
    vSSC.cnt.tx             = 0;
    vSSC.cnt.rx             = 0;
    vSSC.cnt.rxOK           = 0;
    vSSC.tail_detected      = false;
    vSSC.txflags            = SSCTX_COMPLETED;
    vSSC.rxflags            = 0;
    vSSC.errcnt.missheader  = 0;
    vSSC.errcnt.crc         = 0;
    vSSC.errcnt.timeout     = 0;
    vSSC.rectimeout      = 0;
    vSSC.reciv_shift     = 0;
    memset(vSSC.pdcbufRX, 0, SSC_BLOCK_LEN);
    memset(vSSC.bufRX,    0, SSC_BLOCK_LEN);
    FillSscHeader(vSSC.pdcbufTX);
    FillSscFooter(vSSC.pdcbufTX);
    //конфигурируем ножки у SSC
    PIO_Configure(SSC_pins, PIO_LISTSIZE(SSC_pins));
    SSC_Configure(AT91C_BASE_SSC,
                  AT91C_ID_SSC,
                  baudrate,
                  BOARD_MCK);
    //конфигурируем передатчик и приемник:
    SSC_ConfigureTransmitter(AT91C_BASE_SSC,
           (AT91C_SSC_CKS_DIV | AT91C_SSC_CKO_CONTINOUS | AT91C_SSC_START_FALL_RF | 
           SSC_STTDLY(0) | SSC_PERIOD(33) | AT91C_SSC_CKI),
           (SSC_DATLEN(SSC_BIT_PER_FRAME) | SSC_DATNB(1) | SSC_FSLEN(1) | AT91C_SSC_FSOS_POSITIVE));
    SSC_ConfigureReceiver(AT91C_BASE_SSC,
           (AT91C_SSC_CKS_RK | AT91C_SSC_START_FALL_RF | SSC_STTDLY(0) | AT91C_SSC_CKI),
           (SSC_DATLEN(SSC_BIT_PER_FRAME) | SSC_DATNB(1) | SSC_FSLEN(1)));
    //конфигурируем и разрешаем SSC interrupt
    AIC_ConfigureIT(AT91C_ID_SSC, AT91C_AIC_PRIOR_LOWEST+2, ISR_Ssc);
    AIC_EnableIT(AT91C_ID_SSC);
}

//------------------------------------------------------------------------------
/// Interrupt handler для прерывания от DSP (переход в нолик сигнализирует 
/// о начале передачи).
//------------------------------------------------------------------------------
void ISR_INTdsp (void)
{
   if (!PIO_Get(&inINTdsp)) 
   {
      vSSC.cnt.intdsp++;
      
      //Настроим прием
      AT91C_BASE_SSC->SSC_RCR = 0;
#if (SSC_BIT_PER_FRAME < = 8)
      SSC_ReadBuffer(AT91C_BASE_SSC, vSSC.pdcbufRX, SSC_BLOCK_LEN);
#elif (SSC_BIT_PER_FRAME < = 16)
      SSC_ReadBuffer(AT91C_BASE_SSC, vSSC.pdcbufRX, SSC_BLOCK_LEN/2);
#elif (SSC_BIT_PER_FRAME < = 32)
      SSC_ReadBuffer(AT91C_BASE_SSC, vSSC.pdcbufRX, SSC_BLOCK_LEN/4);
#else
#error "SSC_BIT_PER_FRAME invalid"
#endif 
      SSC_EnableReceiver(AT91C_BASE_SSC);
      SSC_EnableInterrupts(AT91C_BASE_SSC, AT91C_SSC_RXBUFF);
   }
}
//------------------------------------------------------------------------------
/// Interrupt handler for the SSC. Срабатывает на события окончания передачи,
/// окончания приема. Сигнализирует об окончании передачи.
//------------------------------------------------------------------------------
void ISR_Ssc(void)
{
   unsigned int status = AT91C_BASE_SSC->SSC_SR;
   u16 RX_RECV_CRC, RX_CALC_CRC;
   TDspAnsw *dspAnsw;
   u16 *pCnt;
   u32 rxidx;
   if ((status & AT91C_SSC_TXBUFE)/* буфер DMA пуст */ && 
       (status & AT91C_SSC_TXENA)/* передатчик включен */) 
   {
      // Передача с использованием PDC закончена
      SSC_DisableInterrupts(AT91C_BASE_SSC, AT91C_SSC_ENDTX | AT91C_SSC_TXBUFE);
      AT91C_BASE_SSC->SSC_PTCR = AT91C_PDC_TXTDIS;
      //ждем, когда последний фрейм выскочит из передатчика
      while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXEMPTY));
      //раньше устанавливали в 1, а теперь делаем вывод PIN_PB23_INTARM_INPUT входом
      // с нагрузочным резистором, что делает то же самое.
      PIO_Configure(&inINTarm, 1);
      SSC_DisableTransmitter(AT91C_BASE_SSC);
      vSSC.txflags |= SSCTX_COMPLETED;
   }
   if ((status & AT91C_SSC_RXBUFF/* буфер DMA полон */) &&
       (status & AT91C_SSC_RXENA/* приемник включен */))
   {
      // Прием с использованием PDC закончен
      SSC_DisableInterrupts(AT91C_BASE_SSC, AT91C_SSC_RXBUFF);
      AT91C_BASE_SSC->SSC_PTCR = AT91C_PDC_RXTDIS;
      SSC_DisableReceiver(AT91C_BASE_SSC);
      vSSC.cnt.rx++;
      ///////////////////////////////////////////////////
      // Обработка пришедшего пакета. Проверим, что приняли,
      // ищем в буфере начало данных по синхробайтам.
      rxidx = 0;
      while (rxidx<20)
      {
         if (vSSC.pdcbufRX[rxidx++] == 0xA5)
            break;
      }
      while (rxidx<20)
      {
         if (vSSC.pdcbufRX[rxidx++] != 0xA5)
            break;
      }
      if (rxidx>=20)
      {
         //не найден конец синхрозаголовка (0xA5) в пределах первых 10 байт
         vSSC.errcnt.missheader++;
         return;
      }
      //заголовок старта найден
      rxidx--;
      //rxidx указывает на команду cmd
      vSSC.reciv_shift = rxidx - SSC_A5_LEN;
      //проверим CRC, для чего копируем в RX_RECV_CRC принятую CRC
      memcpy(&RX_RECV_CRC, &(vSSC.pdcbufRX[rxidx + (SSC_CMD_LEN+SSC_SERVICE_LEN+SSC_DATA_LEN)]), 2);
      RX_CALC_CRC = CRC_START_VAL;
      AddCRC16(&(vSSC.pdcbufRX[rxidx]), (SSC_CMD_LEN+SSC_SERVICE_LEN+SSC_DATA_LEN), &RX_CALC_CRC);
      if (RX_RECV_CRC != RX_CALC_CRC)
      {
         vSSC.errcnt.crc++;
         return;
      }
      else
      {
         ///////////////////////////////////////////////////
         // Конец обработки пришедшего пакета.
         // Если мы здесь, значит успешно завершен прием.
         memcpy(vSSC.bufRX, vSSC.pdcbufRX+rxidx, (SSC_BLOCK_LEN-(SSC_A5_LEN+SSC_E6_LEN)));
         dspAnsw = (TDspAnsw*)vSSC.bufRX;
         dspstate.rxcmd = dspAnsw->cmd;
         vSSC.cnt.rxOK++;
         ((TRawBlock*)vSSC.bufRX)->CRC16 = CRC_START_VAL;
         AddCRC16(&(vSSC.bufRX[6]), 2+32+512, (u16*)&((TRawBlock*)vSSC.bufRX)->CRC16);
      }
      ///////////////////////////////////////////////////
      // Ответная передача в сторону DSP
      if (vSSC.txflags & SSCTX_PACKET_UPDATED)
      {
         FillSscHeader(vSSC.pdcbufTX);
         memcpy(vSSC.pdcbufTX+SSC_A5_LEN, vSSC.bufTX, SSC_BLOCK_LEN-(SSC_A5_LEN+SSC_E6_LEN));
         FillSscFooter(vSSC.pdcbufTX);
         vSSC.txflags &= ~SSCTX_PACKET_UPDATED;
      }
      if ((0==(vSSC.txflags & SSCTX_HANDLER_UPDATED)) && (0!=pdcTXpacket->cmd))
      {
         SSCtransmit();
      }
   }/* if: буфер DMA полон и приемник включен */
}

//набор ножек SPI для аппаратного управления выборкой
#define PINS_GAMEDUINO_CSHW PIN_SPI0_MISO, PIN_SPI0_MOSI, PIN_SPI0_SPCK, PIN_SPI0_CSHW
const Pin pinsGAMEDUINO_CSHW[]    = {PINS_GAMEDUINO_CSHW};
//набор ножек SPI для программного управления выборкой
#define PINS_GAMEDUINO_CSSW PIN_SPI0_MISO, PIN_SPI0_MOSI, PIN_SPI0_SPCK, PIN_SPI0_CSSW
const Pin pinsGAMEDUINO_CSSW[]    = {PINS_GAMEDUINO_CSSW};
 
//буфер DMA для передачи
u32 TXSPIDMAbuf[(4+ZXSPECTRUM_SCREEN_SIZE)];
 
void init_spi_Gameduino (void)
{
   if (useCSHW)
      PIO_Configure(pinsGAMEDUINO_CSHW, PIO_LISTSIZE(pinsGAMEDUINO_CSHW));
   else
      PIO_Configure(pinsGAMEDUINO_CSSW, PIO_LISTSIZE(pinsGAMEDUINO_CSSW));
   AT91C_BASE_PMC->PMC_PCER = ( 1 << GAMEDUINO_ID_SPI );
   // Запрет SPI
   GAMEDUINO_BASE_SPI->SPI_CR = AT91C_SPI_SPIDIS;
   // Инициализация контроллера PDC (DMA) для SPI:
   // запрет PDC TX и RX
   GAMEDUINO_BASE_SPI->SPI_PTCR = AT91C_PDC_TXTDIS | AT91C_PDC_RXTDIS;
   // инициализация счетчиков и указателей на буфер в 0
   // "следующий" буфер TX
   GAMEDUINO_BASE_SPI->SPI_TNPR = 0;
   GAMEDUINO_BASE_SPI->SPI_TNCR = 0;
   // "следующий" буфер RX
   GAMEDUINO_BASE_SPI->SPI_RNPR = 0;
   GAMEDUINO_BASE_SPI->SPI_RNCR = 0;
   // буфер TX
   GAMEDUINO_BASE_SPI->SPI_TPR = 0;
   GAMEDUINO_BASE_SPI->SPI_TCR = 0;
   // буфер RX
   GAMEDUINO_BASE_SPI->SPI_RPR = 0;
   GAMEDUINO_BASE_SPI->SPI_RCR = 0;
   // Разрешение SPI и его сброс
   // "Кажется, что у машины состояний для revB версии должно быть
   // 2 программных сброса SPI, сброс прошел успешно."
   GAMEDUINO_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
   GAMEDUINO_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
   GAMEDUINO_BASE_SPI->SPI_CR = AT91C_SPI_SPIEN;
 
   // Режим SPI: master, FDIV=0, запрет детектирования ошибки конфигурации.
   GAMEDUINO_BASE_SPI->SPI_MR  = AT91C_SPI_MSTR | AT91C_SPI_MODFDIS;
 
   // Установка регистра выборки чипа:
   // 8 бит на передачу, CPOL=1, ClockPhase=0, DLYBCT = 0
   GAMEDUINO_BASE_SPI->SPI_CSR[SPI_CSR_NUM] = AT91C_SPI_CPOL | AT91C_SPI_BITS_8;
   // Разрешение работы SPI
   GAMEDUINO_BASE_SPI->SPI_CR = AT91C_SPI_SPIEN;
}
 
void send_block_to_Gameduino (void *buf, int bytes)
{
   int idx;
 
   init_spi_Gameduino();
 
   LED(1);
   if (!useCSHW)
      PIO_Clear(&pinsGAMEDUINO_CSSW[3]);
   //передача
   if (GAMEDUINO_BASE_SPI->SPI_MR & AT91C_SPI_PS)
   {
      //Подготовка буфера DMA, если SPI_MR.PS=1 (режим переменной периферии)
      for (idx=0; idx<(bytes-1); idx++)
      {
         TXSPIDMAbuf[idx] = ((u8*)buf)[idx];
      }
      TXSPIDMAbuf[idx] = ((u8*)buf)[idx] | AT91C_SPI_LASTXFER;
      while (0 == SPI_WriteBuffer(GAMEDUINO_BASE_SPI, TXSPIDMAbuf, bytes));
   }
   else
      while (0 == SPI_WriteBuffer(GAMEDUINO_BASE_SPI, buf, bytes));
   //ожидание окончания передачи
   while (0 == (GAMEDUINO_BASE_SPI->SPI_SR & AT91C_SPI_TXBUFE));
 
   if (!useCSHW)
      PIO_Set(&pinsGAMEDUINO_CSSW[3]);
   LED(0);
 
   close_spi_Gameduino();
}

//////////////////////////////////////////////////////////////////////////
// Подпрограмма запускает одновременные передачу и прием через DMA.
// Если передача успешно запущена, то будет возвращено 1, иначе (если
// все банки заняты) будет возвращен 0.
unsigned char SPI_RWbuf(AT91S_SPI *spi,
                        void *rxbuf, void *txbuf,
                        unsigned int length)
{
#if !defined(CHIP_SPI_DMA)
   // Проверка доступности первого банка
   if (spi->SPI_TCR == 0)
   {
      spi->SPI_RPR = (unsigned int) rxbuf;
      spi->SPI_TPR = (unsigned int) txbuf;
      spi->SPI_RCR = length;
      spi->SPI_TCR = length;
      spi->SPI_PTCR = (AT91C_PDC_RXTEN | AT91C_PDC_TXTEN);
      return 1;
   }
   // Проверка доступности второго банка
   else if (spi->SPI_TNCR == 0)
   {
      spi->SPI_RNPR = (unsigned int) rxbuf;
      spi->SPI_TNPR = (unsigned int) txbuf;
      spi->SPI_RNCR = length;
      spi->SPI_TNCR = length;
      return 1;
   }
#endif 
   // Нет свободных банков
   return 0;
}