// AN_129_Hi-Speed_JTAG_with_MPSSE.cpp []: определяет точку входа

// в консольное приложение.

#include "stdafx.h"

#include < windows.h >

#include < stdio.h >

#include "ftd2xx.h"

int _tmain(int argc, _TCHAR* argv[])
{
   FT_HANDLE ftHandle;  // хендл для устройства FTDI
   FT_STATUS ftStatus;  // результат каждого вызова D2XX
   DWORD dwNumDevs;     // количество устройств
   unsigned int uiDevIndex = 0xF;   // устройство в списке, которое используется
   BYTE byOutputBuffer[1024];       // буфер, который содержит команды MPSSE, и данные
                                    // для отправки в FT2232H
   BYTE byInputBuffer[1024];        // буфер для хранения данных, прочитанных из FT2232H
   DWORD dwCount = 0;               // главный индекс цикла
   DWORD dwNumBytesToSend = 0;      // индекс выходного буфера
   DWORD dwNumBytesSent = 0;        // счетчик реально отправленных байт -
                                    // используется в FT_Write
   DWORD dwNumBytesToRead = 0;      // количество байт, доступных для чтения во входном
                                    // буфере драйвера
   DWORD dwNumBytesRead = 0;        // количество реально прочитанных данных -
                                    // используется в FT_Read
   DWORD dwClockDivisor = 0x05DB;   // значение делителя тактов, частота SCL = 
                                    // 60/((1+0x05DB)*2) (МГц) = 20 кГц
   // Проверка - присутствует ли устройство FTDI?
   printf("Checking for FTDI devices...\n");
   ftStatus = FT_CreateDeviceInfoList(&dwNumDevs);
   // Получение количества устройств FTDI
   if (ftStatus != FT_OK)  // команда выполнилась успешно?
   {
      printf("Error in getting the number of devices\n");
      return 1;   // Выход по ошибке
   }
   if (dwNumDevs < 1) // Выход, если не видится ни одно устройство
   {
      printf("There are no FTDI devices installed\n");
      return 1;   // Выход по ошибке
   }
   printf("%d FTDI devices found - count includes individual ports on a single chip\n",
          dwNumDevs);
   // Открытие порта - чтобы упростить код, для этого апноута предполагается, что
   // первое устройство будет микросхемой FT2232H или FT4232H. Более тщательные
   // проверки перед открытием порта могут быть сделаны на основе чтения дескрипторов
   // устройства, места подключения, серийного номера и т. д.
   printf("\nAssume first device has the MPSSE and open it...\n");
   ftStatus = FT_Open(0, &ftHandle);
   if (ftStatus != FT_OK)
   {
      printf("Open Failed with error %d\n", ftStatus);
      return 1;   // Выход по ошибке
   }
   // Конфигурирование параметров порта
   printf("\nConfiguring port for MPSSE use...\n");
   ftStatus |= FT_ResetDevice(ftHandle);
   // Сброс устройства USB
   // Сначала очищается буфер приема USB, для чего считываются все старые данные
   // из буфера приема FT2232H. Получение количества байт в буфере приема FT2232H:
   ftStatus |= FT_GetQueueStatus(ftHandle, &dwNumBytesToRead);
   // Чтение данных из буфера приема FT2232H:
   if ((ftStatus == FT_OK) && (dwNumBytesToRead > 0))
      FT_Read(ftHandle, &byInputBuffer, dwNumBytesToRead, &dwNumBytesRead);
   // Установка размеров передачи запроса USB в 64K:
   ftStatus |= FT_SetUSBParameters(ftHandle, 65536, 65535);
   // Запрет символов события и ошибки (event, error characters):
   ftStatus |= FT_SetChars(ftHandle, false, 0, false, 0);
   // Установка таймаута чтения и записи в миллисекундах:
   ftStatus |= FT_SetTimeouts(ftHandle, 0, 5000);
   // Установка таймера латентности (по умолчанию 16 мс):
   ftStatus |= FT_SetLatencyTimer(ftHandle, 16);
   // Сброс контроллера:
   ftStatus |= FT_SetBitMode(ftHandle, 0x0, 0x00);
   // Разрешить режим MPSSE:
   ftStatus |= FT_SetBitMode(ftHandle, 0x0, 0x02);
   if (ftStatus != FT_OK)
   {
      printf("Error in initializing the MPSSE %d\n", ftStatus);
      FT_Close(ftHandle);
      return 1; // Выход по ошибке
   }
   Sleep(50);  // ожидание, чтобы все, связанное с USB, запустилось
               // и начало работать
   // -----------------------------------------------------------
   // В этой точке MPSSE готов для получения команд
   // -----------------------------------------------------------
   // -----------------------------------------------------------
   // Синхронизация MPSSE осуществляется отправкой не существующего
   // кода операции (0xAA), на что MPSSE ответить кодом "Bad
   // Command" (0xFA, ошибочная команда), за которым будет идти
   // сама эта ошибочная команда (0xAA).
   // -----------------------------------------------------------
   // Добавление к очереди ошибочной команды xAA:
   byOutputBuffer[dwNumBytesToSend++] = 0xAA;   //'\xAA';
   // Отправка плохой команды:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   do
   {
      // Получение количества байт во входном буфере устройства:
      ftStatus = FT_GetQueueStatus(ftHandle, &dwNumBytesToRead);
   } while ((dwNumBytesToRead == 0) && (ftStatus == FT_OK));
   // Цикл завершится, если произошла ошибка, или по таймауту
   bool bCommandEchod = false;
   // Чтение данных из входного буфера:
   ftStatus = FT_Read(ftHandle, &byInputBuffer, dwNumBytesToRead, &dwNumBytesRead);
   // Проверка: был ли получен ответ "Bad command" и эхо команды:
   for (dwCount = 0; dwCount < dwNumBytesRead - 1; dwCount++)
   {
      if ((byInputBuffer[dwCount] == 0xFA) && (byInputBuffer[dwCount+1] == 0xAA))
      {
         bCommandEchod = true;
         break;
      }
   }
   if (bCommandEchod == false)
   {
      printf("Error in synchronizing the MPSSE\n");
      FT_Close(ftHandle);
      return 1; // Выход по ошибке
   }
   // -----------------------------------------------------------
   // Конфигурирование настроек MPSSE для JTAG. В блок MPSSE
   // можно послать несколько команд одним вызовом FT_Write.
   // -----------------------------------------------------------
   dwNumBytesToSend = 0;   // начало с чистого индекса
   // Настройка команд, относящихся к Hi-Speed для FTx232H.
   // Использование главной частоты 60 МГц (запрет делителя на 5):
   byOutputBuffer[dwNumBytesToSend++] = 0x8A;
   // Выключение адаптивного тактирования (оно может требоваться для ARM):
   byOutputBuffer[dwNumBytesToSend++] = 0x97;
   // Запрет трехфазного тактирования:
   byOutputBuffer[dwNumBytesToSend++] = 0x8D;
   // Отправка команд, относящихся к Hi-Speed:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // сброс указателя на выходной буфер
   // Установка начальных состояний интерфейса MPSSE - младший байт, оба направления
   // ножек и выходные значения.
   // Имя вывода Сигнал Направление Конфигурация Нач. состояние Конфигурация
   // ADBUS0     TCK    output      1            лог. 0         0
   // ADBUS1     TDI    output      1            лог. 0         0
   // ADBUS2     TDO    input       0                           0
   // ADBUS3     TMS    output      1            лог. 1         1
   // ADBUS4     GPIOL0 input       0                           0
   // ADBUS5     GPIOL1 input       0                           0
   // ADBUS6     GPIOL2 input       0                           0
   // ADBUS7     GPIOL3 input       0                           0
   // Установка бит данных младшего байта порта MPSSE:
   byOutputBuffer[dwNumBytesToSend++] = 0x80;
   // Начальное состояние в вышеуказанной конфигурации:
   byOutputBuffer[dwNumBytesToSend++] = 0x08;
   // Направление работы выводов, как в вышеуказанной конфигурации:
   byOutputBuffer[dwNumBytesToSend++] = 0x0B;
   // Отправка команд конфигурации для младшего GPIO:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // сброс указателя на выходной буфер
   // Установка начальных состояний интерфейса MPSSE - младший байт, оба направления
   // ножек и выходные значения.
   // Имя вывода Сигнал Направление Конфигурация Нач. состояние Конфигурация
   // ACBUS0     GPIOH0 input       0                           0
   // ACBUS1     GPIOH1 input       0                           0
   // ACBUS2     GPIOH2 input       0                           0
   // ACBUS3     GPIOH3 input       0                           0
   // ACBUS4     GPIOH4 input       0                           0
   // ACBUS5     GPIOH5 input       0                           0
   // ACBUS6     GPIOH6 input       0                           0
   // ACBUS7     GPIOH7 input       0                           0
   // Установка бит данных младшего байта порта MPSSE:
   byOutputBuffer[dwNumBytesToSend++] = 0x82;
   // Начальное состояние в вышеуказанной конфигурации:
   byOutputBuffer[dwNumBytesToSend++] = 0x00;
   // Направление работы выводов, как в вышеуказанной конфигурации:
   byOutputBuffer[dwNumBytesToSend++] = 0x00;
   // Отправка команд конфигурации для старшего GPIO:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Установка частоты TCK (0xValueH старший байт значения,
   // 0xValueL младший байт значения):
   // TCK = 60MHz /((1 + [(1 +0xValueH*256) OR 0xValueL])*2)
   // Команда для установки делителя тактов:
   byOutputBuffer[dwNumBytesToSend++] = '\x86';
   // Установка 0xValueL делителя тактов:
   byOutputBuffer[dwNumBytesToSend++] = dwClockDivisor & 0xFF;
   // Установка 0xValueH делителя тактов:
   byOutputBuffer[dwNumBytesToSend++] = (dwClockDivisor >> 8) & 0xFF;
   // Отправка команд для делителя тактов:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Запрет внутренней петли замыкания входа на выход (internal loop-back,
   // эта петля может использоваться для самопроверки):
   byOutputBuffer[dwNumBytesToSend++] = 0x85;
   // Отправка команды запрета loop-back:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Навигация TMS по состояниям Test-Logic-Reset -> Run-Test-Idle ->
   // Select-DR-Scan -> Select-IR-Scan: TMS=1 TMS=0 TMS=1 TMS=1
   // Не читать данные в состояниях Test-Logic-Reset, Run-Test-Idle, Select-DR-Scan,
   // Select-IR-Scan:
   byOutputBuffer[dwNumBytesToSend++] = 0x4B;
   // Количество тактовых импульсов = длина + 1 (здесь 6 тактов):
   byOutputBuffer[dwNumBytesToSend++] = 0x05;
   // Данные сдвигаются младшим битом (LSB) вперед, поэтому для TMS
   // будет шаблон 101100:
   byOutputBuffer[dwNumBytesToSend++] = 0x0D;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // В настоящий TMS = лог. 0. Машина TAP находится в состоянии Shift-IR,
   // так что теперь будем использовать команду TDI/TDO, чтобы выдвинуть единички
   // через выход TDI при чтении входа TDO. Несмотря на то, что нужно вдвинуть 8 бит,
   // здесь тактируется только 7. 8-й будет вдвинут совместно со следующей
   // командой TMS. Данные тактируем на выход через состояния Capture-IR, Shift-IR
   // и Exit-IR, читая при этом возвращаемый результат:
   byOutputBuffer[dwNumBytesToSend++] = 0x3B;
   // Количество тактовых импульсов = длина + 1 (здесь 7 тактов):
   byOutputBuffer[dwNumBytesToSend++] = 0x06;
   // Выдвигаем 1111111 (последний бит игнорируется):
   byOutputBuffer[dwNumBytesToSend++] = 0xFF;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   // Отправка команды TMS:
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Здесь команда TMS, передаваемая с 1 тактом. При этом данные также вдвигаются.
   // Тактирование TMS, чтение одного бита:
   byOutputBuffer[dwNumBytesToSend++] = 0x6B;
   // Количество тактовых импульсов = длина + 1 (здесь 1 такт):
   byOutputBuffer[dwNumBytesToSend++] = 0x00;
   // Данные сдвигаются младшим битом вперед, так что TMS становится лог. 1. Также
   // бит 7 попадает на выход TDI, и также 1 бит лог. 1 оставит TMS в состоянии
   // лог. 1 для следующих команд:
   byOutputBuffer[dwNumBytesToSend++] = 0x83;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Навигация TMS от Exit-IR через Update-IR -> Select-DR-Scan -> Capture-DR:
   // TMS=1 TMS=1 TMS=0
   // Не читаем данные в состояниях Update-IR -> Select-DR-Scan -> Capture-DR
   byOutputBuffer[dwNumBytesToSend++] = 0x4B;
   // Количество тактовых импульсов = длина + 1 (здесь 4 такта):
   byOutputBuffer[dwNumBytesToSend++] = 0x03;
   // Данные сдвигаются младшим битом вперед, так что данные для TMS будут 110:
   byOutputBuffer[dwNumBytesToSend++] = 0x83;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Сейчас TMS = лог. 0. Машина TAP находится в состоянии Shift-DR, так что теперь
   // используем команду TDI/TDO для того, чтобы выдвинуть 101 на выход TDI, читая
   // при этом вход TDO. Несмотря на то, что нужно вдвинуть 3 бита, здесь генерируется
   // только 2 такта. Третий будет выдаваться вместе со следующей командой TMS.
   // Выдвигаем данные наружу через состояния Shift-DR и Exit-DR:
   byOutputBuffer[dwNumBytesToSend++] = 0x3B;
   // Количество тактовых импульсов = длина + 1 (здесь 2 такта):
   byOutputBuffer[dwNumBytesToSend++] = 0x01;
   // Выдвигаем 101 (последний бит игнорируется):
   byOutputBuffer[dwNumBytesToSend++] = 0x01;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Здесь выдается команда TMS с одним тактом. Данные продолжают вдвигаться.
   // Выдвигаем TMS, читаем 1 бит:
   byOutputBuffer[dwNumBytesToSend++] = 0x6B;
   // Количество тактовых импульсов = длина + 1 (здесь 1 такт):
   byOutputBuffer[dwNumBytesToSend++] = 0x00;
   // Данные сдвигаются младшим битом вперед, так что TMS становится в лог. 1. Также
   // бит 7 выдвигается на выход TDI,  и также 1 бит лог. 1 оставит TMS в состоянии
   // лог. 1 для следующих команд:
   byOutputBuffer[dwNumBytesToSend++] = 0x83;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   // Навигация TMS по состояниям Update-DR -> Select-DR-Scan -> Select-IR-Scan
   // -> Test Logic Reset: TMS=1 TMS=1 TMS=1 TMS=1. Не читаем данные в состояниях
   // Update-DR -> Select-DR-Scan -> Select-IR-Scan -> Test Logic Reset:
   byOutputBuffer[dwNumBytesToSend++] = 0x4B;
   // Количество тактовых импульсов = длина + 1 (здесь 4 такта):
   byOutputBuffer[dwNumBytesToSend++] = 0x03;
   // Данные сдвигаются младшим битом вперед, так что данные TMS будут 101100:
   byOutputBuffer[dwNumBytesToSend++] = 0xFF;
   // Отправка команды TMS:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   do
   {
      // Получение количества байт во входном буфере устройства:
      ftStatus = FT_GetQueueStatus(ftHandle, &dwNumBytesToRead);
   } while ((dwNumBytesToRead == 0) && (ftStatus == FT_OK));
   // завершение цикла при ошибке или по таймауту
   // Чтение данных из входного буфера:
   ftStatus = FT_Read(ftHandle, &byInputBuffer, dwNumBytesToRead, &dwNumBytesRead);
   printf("\n");
   printf("TI SN74BCT8244A IR default value is 0x81\n");
   printf("The value scanned by the FT2232H is 0x%x\n",
          byInputBuffer[dwNumBytesRead - 3]);
   printf("\n");
   printf("TI SN74BCT8244A DR bypass expected data is 00000010 = 0x2\n");
   printf(" The value scanned by the FT2232H = 0x%x\n",
          (byInputBuffer[dwNumBytesRead-1] >> 5));
   // Генерация тактов для получения состояния Test-Logic-Reset. В состоянии
   // Test-Logic-Reset не производится никаких действий, только демонстрируется
   // генерация тактов без какой-либо передачи данных. Генерация тактов:
   byOutputBuffer[dwNumBytesToSend++] = 0x8F;
   // (0x0002 + 1) * 8 = 24 такта
   byOutputBuffer[dwNumBytesToSend++] = 0x02;
   byOutputBuffer[dwNumBytesToSend++] = 0x00;
   // Выдача команд для тактов:
   ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0; // сброс указателя на выходной буфер
   /*

   // -----------------------------------------------------------

   // Закроем все используемые ресурсы:

   // -----------------------------------------------------------

   */
   printf("\nJTAG program executed successfully.\n");
   printf("Press Enter to continue\n");
   getchar();           // Ожидание нажатия клавиши возврата каретки
   FT_Close(ftHandle);  // Закрытие порта
   return 0;            // Успешный выход из программы
}