/*! \fn guiDisplayInsertSmartCardScreenAndWait(void)
* \brief Ask for the user to insert his smart card
* \return RETURN_OK if the user inserted and unlocked his smartcard
*/
RET_TYPE guiDisplayInsertSmartCardScreenAndWait(void)
{
RET_TYPE card_detect_ret = RETURN_JRELEASED;
//#define KEYBOARD_LAYOUT_TEST
#ifdef KEYBOARD_LAYOUT_TEST
for (uint8_t i = ' '; i <= '~'; i++)
{
usbKeybPutChar(i);
usbKeybPutChar(i);
}
//setMooltipassParameterInEeprom(KEYBOARD_LAYOUT_PARAM, getMooltipassParameterInEeprom(KEYBOARD_LAYOUT_PARAM)+1);
//if (getMooltipassParameterInEeprom(KEYBOARD_LAYOUT_PARAM) > LAST_KEYB_LUT)
//{
// setMooltipassParameterInEeprom(KEYBOARD_LAYOUT_PARAM, FIRST_KEYB_LUT);
//}
#endif
// Switch on lights
activityDetectedRoutine();
// Draw insert bitmap
oledClear();
oledBitmapDrawFlash(0, 0, BITMAP_INSERT, 0);
oledFlipBuffers(0,0);
// Wait for either timeout or for the user to insert his smartcard
while ((hasTimerExpired(TIMER_USERINT, TRUE) == TIMER_RUNNING) && (card_detect_ret != RETURN_JDETECT))
{
card_detect_ret = isCardPlugged();
touchDetectionRoutine(0);
}
// If the user didn't insert his smart card
if (card_detect_ret != RETURN_JDETECT)
{
// Get back to other screen
guiGetBackToCurrentScreen();
return RETURN_NOK;
}
else
{
return handleSmartcardInserted();
}
}
/*! \fn main(void)
* \brief Main function
*/
int main(void)
{
uint16_t current_bootkey_val = eeprom_read_word((uint16_t*)EEP_BOOTKEY_ADDR);
RET_TYPE flash_init_result;
RET_TYPE touch_init_result;
RET_TYPE card_detect_ret;
uint8_t fuse_ok = TRUE;
// Disable JTAG to gain access to pins, set prescaler to 1 (fuses not set)
#ifndef PRODUCTION_KICKSTARTER_SETUP
disableJTAG();
CPU_PRESCALE(0);
#endif
// Check fuse settings: boot reset vector, 2k words, SPIEN, BOD 2.6V, programming & ver disabled
if ((boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS) != 0xFF) || (boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS) != 0xD8) || (boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS) != 0xFB) || (boot_lock_fuse_bits_get(GET_LOCK_BITS) != 0xFC))
{
fuse_ok = FALSE;
}
// Check if PB5 is low to start electrical test
DDRB &= ~(1 << 5); PORTB |= (1 << 5);
smallForLoopBasedDelay();
if (!(PINB & (1 << 5)))
{
// Test result, true by default
uint8_t test_result = TRUE;
// Leave flash nS off
DDR_FLASH_nS |= (1 << PORTID_FLASH_nS);
PORT_FLASH_nS |= (1 << PORTID_FLASH_nS);
// Set PORTD as output, leave PORTID_OLED_SS high
DDRD |= 0xFF; PORTD |= 0xFF;
// All other pins are input by default, run our test
for (uint8_t i = 0; i < 4; i++)
{
PORTD |= 0xFF;
smallForLoopBasedDelay();
if (!(PINF & (0xC3)) || !(PINC & (1 << 6)) || !(PINE & (1 << 6)) || !(PINB & (1 << 4)))
{
test_result = FALSE;
}
PORTD &= (1 << PORTID_OLED_SS);
smallForLoopBasedDelay();
if ((PINF & (0xC3)) || (PINC & (1 << 6)) || (PINE & (1 << 6)) || (PINB & (1 << 4)))
{
test_result = FALSE;
}
}
// PB6 as test result output
DDRB |= (1 << 6);
// If test successful, light green LED
if ((test_result == TRUE) && (fuse_ok == TRUE))
{
PORTB |= (1 << 6);
}
else
{
PORTB &= ~(1 << 6);
}
while(1);
}
// This code will only be used for developers and beta testers
#if !defined(PRODUCTION_SETUP) && !defined(PRODUCTION_KICKSTARTER_SETUP)
// Check if we were reset and want to go to the bootloader
if (current_bootkey_val == BOOTLOADER_BOOTKEY)
{
// Disable WDT
wdt_reset();
wdt_clear_flag();
wdt_change_enable();
wdt_stop();
// Store correct bootkey
eeprom_write_word((uint16_t*)EEP_BOOTKEY_ADDR, CORRECT_BOOTKEY);
// Jump to bootloader
start_bootloader();
}
// Check if there was a change in the mooltipass setting storage to reset the parameters to their correct values
if (getMooltipassParameterInEeprom(USER_PARAM_INIT_KEY_PARAM) != USER_PARAM_CORRECT_INIT_KEY)
{
mooltipassParametersInit();
setMooltipassParameterInEeprom(USER_PARAM_INIT_KEY_PARAM, USER_PARAM_CORRECT_INIT_KEY);
}
#endif
// First time initializations for Eeprom (first boot at production or flash layout changes for beta testers)
if (current_bootkey_val != CORRECT_BOOTKEY)
{
// Erase Mooltipass parameters
mooltipassParametersInit();
// Set bootloader password bool to FALSE
eeprom_write_byte((uint8_t*)EEP_BOOT_PWD_SET, FALSE);
}
/* Check if a card is inserted in the Mooltipass to go to the bootloader */
#ifdef AVR_BOOTLOADER_PROGRAMMING
/* Disable JTAG to get access to the pins */
disableJTAG();
/* Init SMC port */
initPortSMC();
/* Delay for detection */
smallForLoopBasedDelay();
#if defined(HARDWARE_V1)
if (PIN_SC_DET & (1 << PORTID_SC_DET))
#elif defined(HARDWARE_OLIVIER_V1)
if (!(PIN_SC_DET & (1 << PORTID_SC_DET)))
#endif
{
uint16_t tempuint16;
/* What follows is a copy from firstDetectFunctionSMC() */
/* Enable power to the card */
PORT_SC_POW &= ~(1 << PORTID_SC_POW);
/* Default state: PGM to 0 and RST to 1 */
PORT_SC_PGM &= ~(1 << PORTID_SC_PGM);
DDR_SC_PGM |= (1 << PORTID_SC_PGM);
PORT_SC_RST |= (1 << PORTID_SC_RST);
DDR_SC_RST |= (1 << PORTID_SC_RST);
/* Activate SPI port */
PORT_SPI_NATIVE &= ~((1 << SCK_SPI_NATIVE) | (1 << MOSI_SPI_NATIVE));
DDRB |= (1 << SCK_SPI_NATIVE) | (1 << MOSI_SPI_NATIVE);
setSPIModeSMC();
/* Let the card come online */
smallForLoopBasedDelay();
/* Check smart card FZ */
readFabricationZone((uint8_t*)&tempuint16);
if ((swap16(tempuint16)) != SMARTCARD_FABRICATION_ZONE)
{
removeFunctionSMC();
start_bootloader();
}
else
{
removeFunctionSMC();
}
}
#endif
initPortSMC(); // Initialize smart card port
initPwm(); // Initialize PWM controller
initIRQ(); // Initialize interrupts
powerSettlingDelay(); // Let the power settle
initUsb(); // Initialize USB controller
powerSettlingDelay(); // Let the USB 3.3V LDO rise
initI2cPort(); // Initialize I2C interface
rngInit(); // Initialize avrentropy library
oledInitIOs(); // Initialize OLED input/outputs
spiUsartBegin(SPI_RATE_8_MHZ); // Start USART SPI at 8MHz
// If offline mode isn't enabled, wait for device to be enumerated
if (getMooltipassParameterInEeprom(OFFLINE_MODE_PARAM) == FALSE)
{
while(!isUsbConfigured()); // Wait for host to set configuration
}
// Set correct timeout_enabled val
mp_timeout_enabled = getMooltipassParameterInEeprom(LOCK_TIMEOUT_ENABLE_PARAM);
// Launch the before flash initialization tests
#ifdef TESTS_ENABLED
beforeFlashInitTests();
#endif
// Check if we can initialize the Flash memory
flash_init_result = initFlash();
// Launch the after flash initialization tests
#ifdef TESTS_ENABLED
afterFlashInitTests();
#endif
// Set up OLED now that USB is receiving full 500mA.
oledBegin(FONT_DEFAULT);
// First time initializations for Flash (first time power up at production)
if (current_bootkey_val != CORRECT_BOOTKEY)
{
// Erase everything non graphic in flash
eraseFlashUsersContents();
// Erase # of cards and # of users
firstTimeUserHandlingInit();
}
// Check if we can initialize the touch sensing element
touch_init_result = initTouchSensing();
// Enable proximity detection
#ifndef HARDWARE_V1
activateProxDetection();
#endif
// Launch the after touch initialization tests
#ifdef TESTS_ENABLED
afterTouchInitTests();
#endif
// Test procedure to check that all HW is working
#if defined(PRODUCTION_SETUP) || defined(PRODUCTION_KICKSTARTER_SETUP)
if (current_bootkey_val != CORRECT_BOOTKEY)
{
RET_TYPE temp_rettype;
// Wait for USB host to upload bundle, which then sets USER_PARAM_INIT_KEY_PARAM
//#ifdef PRODUCTION_KICKSTARTER_SETUP
while(getMooltipassParameterInEeprom(USER_PARAM_INIT_KEY_PARAM) != 0xF1)
{
usbProcessIncoming(USB_CALLER_MAIN);
}
//#endif
// Bundle uploaded, start the screen
oledBegin(FONT_DEFAULT);
oledWriteActiveBuffer();
oledSetXY(0,0);
// LEDs ON, to check
setPwmDc(MAX_PWM_VAL);
switchOnButtonWheelLeds();
guiDisplayRawString(ID_STRING_TEST_LEDS_CH);
// Check flash init
if (flash_init_result != RETURN_OK)
{
guiDisplayRawString(ID_STRING_TEST_FLASH_PB);
}
// Check touch init
if (touch_init_result != RETURN_OK)
{
guiDisplayRawString(ID_STRING_TEST_TOUCH_PB);
}
// Touch instructions
guiDisplayRawString(ID_STRING_TEST_INST_TCH);
// Check prox
while(!(touchDetectionRoutine(0) & RETURN_PROX_DETECTION));
guiDisplayRawString(ID_STRING_TEST_DET);
activateGuardKey();
// Check left
while(!(touchDetectionRoutine(0) & RETURN_LEFT_PRESSED));
guiDisplayRawString(ID_STRING_TEST_LEFT);
// Check wheel
while(!(touchDetectionRoutine(0) & RETURN_WHEEL_PRESSED));
guiDisplayRawString(ID_STRING_TEST_WHEEL);
// Check right
while(!(touchDetectionRoutine(0) & RETURN_RIGHT_PRESSED));
guiDisplayRawString(ID_STRING_TEST_RIGHT);
// Insert card
guiDisplayRawString(ID_STRING_TEST_CARD_INS);
while(isCardPlugged() != RETURN_JDETECT);
temp_rettype = cardDetectedRoutine();
// Check card
if (!((temp_rettype == RETURN_MOOLTIPASS_BLANK) || (temp_rettype == RETURN_MOOLTIPASS_USER)))
{
guiDisplayRawString(ID_STRING_TEST_CARD_PB);
}
// Display result
uint8_t script_return = RETURN_OK;
if ((flash_init_result == RETURN_OK) && (touch_init_result == RETURN_OK) && ((temp_rettype == RETURN_MOOLTIPASS_BLANK) || (temp_rettype == RETURN_MOOLTIPASS_USER)))
{
// Inform script of success
usbSendMessage(CMD_FUNCTIONAL_TEST_RES, 1, &script_return);
// Wait for password to be set
while(eeprom_read_byte((uint8_t*)EEP_BOOT_PWD_SET) != BOOTLOADER_PWDOK_KEY)
{
usbProcessIncoming(USB_CALLER_MAIN);
}
// Display test result
guiDisplayRawString(ID_STRING_TEST_OK);
timerBasedDelayMs(3000);
}
else
{
// Set correct bool
script_return = RETURN_NOK;
// Display test result
guiDisplayRawString(ID_STRING_TEST_NOK);
// Inform script of failure
usbSendMessage(CMD_FUNCTIONAL_TEST_RES, 1, &script_return);
while(1)
{
usbProcessIncoming(USB_CALLER_MAIN);
}
}
}
#endif
// Stop the Mooltipass if we can't communicate with the flash or the touch interface
#if defined(HARDWARE_OLIVIER_V1)
#ifdef PRODUCTION_KICKSTARTER_SETUP
while ((flash_init_result != RETURN_OK) || (touch_init_result != RETURN_OK) || (fuse_ok != TRUE));
#else
while ((flash_init_result != RETURN_OK) || (touch_init_result != RETURN_OK));
#endif
#endif
// First time initializations done.... write correct value in eeprom
if (current_bootkey_val != CORRECT_BOOTKEY)
{
// Store correct bootkey
eeprom_write_word((uint16_t*)EEP_BOOTKEY_ADDR, CORRECT_BOOTKEY);
}
// Write inactive buffer & go to startup screen
oledWriteInactiveBuffer();
guiSetCurrentScreen(SCREEN_DEFAULT_NINSERTED);
guiGetBackToCurrentScreen();
// Launch the after HaD logo display tests
#ifdef TESTS_ENABLED
afterHadLogoDisplayTests();
#endif
// Let's fade in the LEDs
for (uint16_t i = 0; i < MAX_PWM_VAL; i++)
{
setPwmDc(i);
timerBasedDelayMs(0);
}
activityDetectedRoutine();
launchCalibrationCycle();
touchClearCurrentDetections();
// Inhibit touch inputs for the first 3 seconds
activateTimer(TIMER_TOUCH_INHIBIT, 3000);
while (1)
{
// Process possible incoming USB packets
usbProcessIncoming(USB_CALLER_MAIN);
// Call GUI routine once the touch input inhibit timer is finished
if (hasTimerExpired(TIMER_TOUCH_INHIBIT, FALSE) == TIMER_EXPIRED)
{
guiMainLoop();
}
// Check if a card just got inserted / removed
card_detect_ret = isCardPlugged();
// Do appropriate actions on smartcard insertion / removal
if (card_detect_ret == RETURN_JDETECT)
{
// Light up the Mooltipass and call the dedicated function
activityDetectedRoutine();
handleSmartcardInserted();
}
else if (card_detect_ret == RETURN_JRELEASED)
{
// Light up the Mooltipass and call the dedicated function
activityDetectedRoutine();
handleSmartcardRemoved();
// Set correct screen
guiDisplayInformationOnScreen(ID_STRING_CARD_REMOVED);
guiSetCurrentScreen(SCREEN_DEFAULT_NINSERTED);
userViewDelay();
guiGetBackToCurrentScreen();
}
// Two quick caps lock presses wakes up the device
if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_EXPIRED) && (getKeyboardLeds() & HID_CAPS_MASK) && (wasCapsLockTimerArmed == FALSE))
{
wasCapsLockTimerArmed = TRUE;
activateTimer(TIMER_CAPS, CAPS_LOCK_DEL);
}
else if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_RUNNING) && !(getKeyboardLeds() & HID_CAPS_MASK))
{
activityDetectedRoutine();
}
else if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_EXPIRED) && !(getKeyboardLeds() & HID_CAPS_MASK))
{
wasCapsLockTimerArmed = FALSE;
}
// If we have a timeout lock
if ((mp_timeout_enabled == TRUE) && (hasTimerExpired(SLOW_TIMER_LOCKOUT, TRUE) == TIMER_EXPIRED))
{
guiSetCurrentScreen(SCREEN_DEFAULT_INSERTED_LCK);
guiGetBackToCurrentScreen();
handleSmartcardRemoved();
}
}
}
/*! \fn guiScreenLoop(uint8_t input_interface_result)
* \brief Function called to handle screen changes
* \param input_interface_result Touch detection result
*/
void guiScreenLoop(uint8_t input_interface_result)
{
// If no press, you can return!
if ((input_interface_result == WHEEL_ACTION_NONE) || (currentScreen == SCREEN_DEFAULT_INSERTED_INVALID) || (currentScreen == SCREEN_DEFAULT_INSERTED_UNKNOWN))
{
return;
}
if (currentScreen == SCREEN_DEFAULT_NINSERTED)
{
// No smart card inserted, ask the user to insert one
guiDisplayInsertSmartCardScreenAndWait();
}
else if (currentScreen == SCREEN_MEMORY_MGMT)
{
// Currently in memory management mode, tell the user to finish it via the plugin/app
guiDisplayInformationOnScreenAndWait(ID_STRING_CLOSEMEMMGMT);
guiGetBackToCurrentScreen();
miniWheelClearDetections();
}
else if (currentScreen == SCREEN_DEFAULT_INSERTED_LCK)
{
// Locked screen and a detection happened, check that the user hasn't removed his card, launch unlocking process
if ((cardDetectedRoutine() == RETURN_MOOLTIPASS_USER) && (validCardDetectedFunction(0, TRUE) == RETURN_VCARD_OK))
{
// User approved his pin
unlockFeatureCheck();
currentScreen = SCREEN_DEFAULT_INSERTED_NLCK;
}
// Go to the new screen
guiGetBackToCurrentScreen();
}
else
{
if (input_interface_result == WHEEL_ACTION_UP)
{
// We can do that because of defines and bitmap order (see logic_fw_flash_storage and gui.h)
if (currentScreen == SCREEN_LOCK)
{
currentScreen = SCREEN_SETTINGS;
}
else if (currentScreen == SCREEN_SETTINGS_CHANGE_PIN)
{
currentScreen = SCREEN_SETTINGS_ERASE;
}
else
{
currentScreen--;
}
// We can do that because of defines and bitmap order (see logic_fw_flash_storage and gui.h)
for (uint8_t i = 0; i < NB_BMPS_PER_TRANSITION; i++)
{
miniOledBitmapDrawFlash(0, 0, (currentScreen-SCREEN_LOCK)*NB_BMPS_PER_TRANSITION+BITMAP_MAIN_LOCK+NB_BMPS_PER_TRANSITION-1-i, OLED_SCROLL_FLIP);
timerBasedDelayMs(12);
}
}
else if (input_interface_result == WHEEL_ACTION_DOWN)
{
// We can do that because of defines and bitmap order (see logic_fw_flash_storage and gui.h)
for (uint8_t i = 0; i < NB_BMPS_PER_TRANSITION-1; i++)
{
miniOledBitmapDrawFlash(0, 0, (currentScreen-SCREEN_LOCK)*NB_BMPS_PER_TRANSITION+BITMAP_MAIN_LOCK+1+i, OLED_SCROLL_FLIP);
timerBasedDelayMs(12);
}
if (currentScreen == SCREEN_SETTINGS)
{
currentScreen = SCREEN_LOCK;
}
else if (currentScreen == SCREEN_SETTINGS_ERASE)
{
currentScreen = SCREEN_SETTINGS_CHANGE_PIN;
}
else
{
currentScreen++;
}
miniOledBitmapDrawFlash(0, 0, (currentScreen-SCREEN_LOCK)*NB_BMPS_PER_TRANSITION+BITMAP_MAIN_LOCK, OLED_SCROLL_FLIP);
}
else if (input_interface_result == WHEEL_ACTION_LONG_CLICK)
{
// Long press in main menu : lock, long press in settings menu: go back to login screen
if ((currentScreen >= SCREEN_SETTINGS_CHANGE_PIN) && (currentScreen <= SCREEN_SETTINGS_ERASE))
{
currentScreen = SCREEN_LOGIN;
miniOledBitmapDrawFlash(0, 0, (currentScreen-SCREEN_LOCK)*NB_BMPS_PER_TRANSITION+BITMAP_MAIN_LOCK, OLED_SCROLL_UP);
}
}
else if (input_interface_result == WHEEL_ACTION_SHORT_CLICK)
{
switch(currentScreen)
{
case SCREEN_LOCK:
{
// User wants to lock his mooltipass
currentScreen = SCREEN_DEFAULT_INSERTED_LCK;
handleSmartcardRemoved();
guiGetBackToCurrentScreen();
break;
}
case SCREEN_LOGIN:
{
// User wants to go to the login menu
if (getStartingParentAddress() != NODE_ADDR_NULL)
{
loginSelectLogic();
}
else
{
guiDisplayInformationOnScreenAndWait(ID_STRING_NO_CREDS);
}
guiGetBackToCurrentScreen();
break;
}
case SCREEN_FAVORITES:
{
// User wants to go to the favorite menu
#if defined(ENABLE_CREDENTIAL_MANAGEMENT) && defined(REPLACE_FAVORITES_WITH_CREDENTIAL_MANAGEMENT)
managementActionPickingLogic();
#else
favoritePickingLogic();
#endif
guiGetBackToCurrentScreen();
break;
}
case SCREEN_SETTINGS:
{
currentScreen = SCREEN_SETTINGS_CHANGE_PIN;
miniOledBitmapDrawFlash(0, 0, (currentScreen-SCREEN_LOCK)*NB_BMPS_PER_TRANSITION+BITMAP_MAIN_LOCK, OLED_SCROLL_UP);
break;
}
case SCREEN_SETTINGS_HOME:
{
currentScreen = SCREEN_LOGIN;
miniOledBitmapDrawFlash(0, 0, (currentScreen-SCREEN_LOCK)*NB_BMPS_PER_TRANSITION+BITMAP_MAIN_LOCK, OLED_SCROLL_UP);
break;
}
case SCREEN_SETTINGS_CHANGE_PIN:
{
// User wants to change his PIN code
// Reauth user
if (removeCardAndReAuthUser() == RETURN_OK)
{
// User approved his pin, ask his new one
volatile uint16_t pin_code;
if (guiAskForNewPin(&pin_code, ID_STRING_NEW_PINQ) == RETURN_NEW_PIN_OK)
{
// User successfully entered a new pin
writeSecurityCode(&pin_code);
// Inform of success
guiDisplayInformationOnScreenAndWait(ID_STRING_PIN_CHANGED);
}
else
{
// Inform of fail
guiDisplayInformationOnScreenAndWait(ID_STRING_PIN_NCGHANGED);
}
pin_code = 0x0000;
}
else
{
currentScreen = SCREEN_DEFAULT_INSERTED_LCK;
}
guiGetBackToCurrentScreen();
break;
}
case SCREEN_SETTINGS_BACKUP:
{
// User wants to clone his smartcard
volatile uint16_t pin_code;
RET_TYPE temp_rettype;
// Reauth user
if (removeCardAndReAuthUser() == RETURN_OK)
{
// Ask for new pin
temp_rettype = guiAskForNewPin(&pin_code, ID_STRING_PIN_NEW_CARD);
if (temp_rettype == RETURN_NEW_PIN_OK)
{
// Start the cloning process
if (cloneSmartCardProcess(&pin_code) == RETURN_OK)
{
// Well it worked....
}
else
{
currentScreen = SCREEN_DEFAULT_INSERTED_LCK;
guiDisplayInformationOnScreen(ID_STRING_TGT_CARD_NBL);
}
pin_code = 0x0000;
}
else if (temp_rettype == RETURN_NEW_PIN_DIFF)
{
currentScreen = SCREEN_DEFAULT_INSERTED_LCK;
guiDisplayInformationOnScreen(ID_STRING_PIN_DIFF);
}
else
{
guiGetBackToCurrentScreen();
return;
}
}
else
{
currentScreen = SCREEN_DEFAULT_INSERTED_LCK;
guiDisplayInformationOnScreen(ID_STRING_FAILED);
}
userViewDelay();
guiGetBackToCurrentScreen();
break;
}
case SCREEN_SETTINGS_ERASE:
{
// User wants to delete his profile in flash / eeprom....
if ((guiAskForConfirmation(1, (confirmationText_t*)readStoredStringToBuffer(ID_STRING_AREYOUSURE)) == RETURN_OK) && (removeCardAndReAuthUser() == RETURN_OK) && (guiAskForConfirmation(1, (confirmationText_t*)readStoredStringToBuffer(ID_STRING_AREYOURLSURE)) == RETURN_OK))
{
uint8_t currentuserid = getCurrentUserID();
guiDisplayProcessingScreen();
deleteCurrentUserFromFlash();
if (guiAskForConfirmation(1, (confirmationText_t*)readStoredStringToBuffer(ID_STRING_ERASE_TCARD)) == RETURN_OK)
{
guiDisplayProcessingScreen();
eraseSmartCard();
// Erase other smartcards
while (guiAskForConfirmation(1, (confirmationText_t*)readStoredStringToBuffer(ID_STRING_OTHECARDFUSER)) == RETURN_OK)
{
// Ask the user to insert other smartcards
guiDisplayInformationOnScreen(ID_STRING_INSERT_OTHER);
// Wait for the user to remove and enter another smartcard
while (isCardPlugged() != RETURN_JRELEASED);
// Wait for the user to insert a new smart card
while (isCardPlugged() != RETURN_JDETECT);
guiDisplayProcessingScreen();
// Check the card type & ask user to enter his pin, check that the new user id loaded by validCardDetectedFunction is still the same
if ((cardDetectedRoutine() == RETURN_MOOLTIPASS_USER) && (validCardDetectedFunction(0, FALSE) == RETURN_VCARD_OK) && (currentuserid == getCurrentUserID()))
{
eraseSmartCard();
}
}
}
// Delete LUT entries
guiDisplayProcessingScreen();
deleteUserIdFromSMCUIDLUT(currentuserid);
// Go to invalid screen
currentScreen = SCREEN_DEFAULT_INSERTED_INVALID;
}
else
{
currentScreen = SCREEN_DEFAULT_INSERTED_LCK;
}
userViewDelay();
handleSmartcardRemoved();
guiGetBackToCurrentScreen();
break;
}
default: break;
}
}
}
}
/*! \fn main(void)
* \brief Main function
*/
int main(void)
{
RET_TYPE flash_init_result = RETURN_NOK;
RET_TYPE card_detect_ret;
RET_TYPE temp_rettype;
uint8_t temp_buffer[200];
char temp_string[20];
CPU_PRESCALE(0); // Set for 16MHz clock
_delay_ms(500); // Let the power settle
initPortSMC(); // Init smart card Port
initIRQ(); // Init interrupts
usb_init(); // Init USB controller
while(!usb_configured()); // Wait for host to set configuration
initOLED(); // Init OLED screen after enum
flash_init_result = initFlash(); // Init flash memory
//#define TEST_HID_AND_CDC
#ifdef TEST_HID_AND_CDC
//Show_String("Z",FALSE,2,0);
//usb_keyboard_press(KEY_S, 0);
while(1)
{
int n = usb_serial_getchar();
if (n >= 0)
{
usb_serial_putchar(n);
Show_String((char*)&n,FALSE,2,0);
//usb_keyboard_press(n,0);
}
}
#endif /* TEST_HID_AND_CDC */
//lcd_display_grayscale();
if(flash_init_result == RETURN_OK)
Show_String("Flash init ok", FALSE, 2, 0);
else
Show_String("Problem flash init", FALSE, 2, 250);
//display_picture(HACKADAY_BMP, 20, 0);
//draw_screen_frame();
//Show_String("Mooltipass", FALSE, 32, 10);
Show_String("No card detected", FALSE, 25, 45); //If no card is inserted at boot time
while(1)
{
card_detect_ret = isCardPlugged();
if(card_detect_ret == RETURN_JDETECT) // Card just detected
{
temp_rettype = cardDetectedRoutine();
if(temp_rettype == RETURN_MOOLTIPASS_INVALID) // Invalid card
{
_delay_ms(3000);
printSMCDebugInfoToScreen();
removeFunctionSMC(); // Shut down card reader
}
else if(temp_rettype == RETURN_MOOLTIPASS_PB) // Problem with card
{
_delay_ms(3000);
printSMCDebugInfoToScreen();
removeFunctionSMC(); // Shut down card reader
}
else if(temp_rettype == RETURN_MOOLTIPASS_BLOCKED) // Card blocked
{
_delay_ms(3000);
printSMCDebugInfoToScreen();
removeFunctionSMC(); // Shut down card reader
}
else if(temp_rettype == RETURN_MOOLTIPASS_BLANK) // Blank mooltipass card
{
// Here we should ask the user to setup his mooltipass card
_delay_ms(3000);
printSMCDebugInfoToScreen();
removeFunctionSMC(); // Shut down card reader
}
else if(temp_rettype == RETURN_MOOLTIPASS_USER) // Configured mooltipass card
{
// Here we should ask the user for his pin and call mooltipassdetect
_delay_ms(3000);
printSMCDebugInfoToScreen();
removeFunctionSMC(); // Shut down card reader
}
/*read_credential_block_within_flash_page(2,1,temp_buffer);
for(i = 0; i < 10; i++)
{
hexachar_to_string(temp_buffer[i], temp_string);
Show_String(temp_string, FALSE, 2+i*5, 0);
}
temp_buffer[3] = 0x0A;
write_credential_block_within_flash_page(2,1, temp_buffer);
read_credential_block_within_flash_page(2,1,temp_buffer);
for(i = 0; i < 10; i++)
{
hexachar_to_string(temp_buffer[i], temp_string);
Show_String(temp_string, FALSE, 2+i*5, 8);
}*/
}
else if(card_detect_ret == RETURN_JRELEASED) //card just released
{
removeFunctionSMC();
clear_screen();
Show_String("Please insert card", FALSE, 2, 8);
}
}
}
