pio_type platform_pio_op( unsigned port, pio_type pinmask, int op )
{
  Pin* pin;
  pio_type retval = 1;
  
  pin = pio_port_desc + port;
  pin->mask = pinmask;
  switch( op )
  {
    case PLATFORM_IO_PORT_SET_VALUE:    
    case PLATFORM_IO_PIN_SET:
      PIO_Set( pin );
      break;
      
    case PLATFORM_IO_PIN_CLEAR:
      PIO_Clear( pin );
      break;
      
    case PLATFORM_IO_PORT_DIR_INPUT:
      pin->mask = 0x7FFFFFFF;      
    case PLATFORM_IO_PIN_DIR_INPUT:
      pin->type = PIO_INPUT;
      PIO_Configure( pin, 1 );
      break;
      
    case PLATFORM_IO_PORT_DIR_OUTPUT:      
      pin->mask = 0x7FFFFFFF;      
    case PLATFORM_IO_PIN_DIR_OUTPUT:
      pin->type = PIO_OUTPUT_0;
      PIO_Configure( pin, 1 );
      break;      
            
    case PLATFORM_IO_PORT_GET_VALUE:
      pin->mask = 0x7FFFFFFF;
      pin->type = PIO_INPUT;
      retval = PIO_Get( pin );
      break;
      
    case PLATFORM_IO_PIN_GET:
      retval = PIO_Get( pin ) & pinmask ? 1 : 0;
      break;
      
    case PLATFORM_IO_PIN_PULLUP:
      pin->pio->PIO_PPUER = pinmask;
      break;
      
    case PLATFORM_IO_PIN_NOPULL:
      pin->pio->PIO_PPUDR = pinmask;
      break;
      
    default:
      retval = 0;
      break;
  }
  return retval;
}

/**
 * @brief Interrupt handler for Button 2 - decrements the counter value
 */
static void ISR_Bp2(void)
{
    // Check if the button has been pressed
    if (!PIO_Get(&pinPB2))
    {
        //wait until button gets released
        while (!PIO_Get(&pinPB2))
            ;

        counter = ((counter-1)%8);
    }
}

uint8_t stepper_get_step_mode(void) {
	bool usm[2] = {PIO_Get(&pin_usm[0]), PIO_Get(&pin_usm[1])};
	if(!usm[0] && !usm[1]) {
		return STEP_MODE_FULL;
	} else if(usm[0] && !usm[1]) {
		return STEP_MODE_HALF;
	} else if(!usm[0] && usm[1]) {
		return STEP_MODE_QUARTER;
	} else {
		return STEP_MODE_EIGTH;
	}
}

static void prvConfigureVBus( void )
{
const Pin xVBusPin = PIN_USB_VBUS;
const uint32_t ulPriority = 7; /* Highest. */

	/* Configure PIO to generate an interrupt on status change. */
    PIO_Configure( &xVBusPin, 1 );
    PIO_ConfigureIt( &xVBusPin );

	/* Ensure interrupt is disabled before setting the mode and installing the
	handler.  The priority of the tick interrupt should always be set to the
	lowest possible. */
	AIC->AIC_SSR  = ID_PIOE;
	AIC->AIC_IDCR = AIC_IDCR_INTD;
	AIC->AIC_SMR  = AIC_SMR_SRCTYPE_EXT_POSITIVE_EDGE | ulPriority;
	AIC->AIC_SVR = ( uint32_t ) prvVBusISRHandler;

	/* Start with the interrupt clear. */
	AIC->AIC_ICCR = AIC_ICCR_INTCLR;
	PIO_EnableIt( &xVBusPin );
    AIC_EnableIT( ID_PIOE );

	/* Check current level on VBus */
	if( PIO_Get( &xVBusPin ) != pdFALSE )
	{
		/* If VBUS present, force the connect */
		USBD_Connect();
	}
	else
	{
		USBD_Disconnect();
	}
}

//------------------------------------------------------------------------------
/// Interrupt service routine for the PIT. Debounces the wake-up pin input.
//------------------------------------------------------------------------------
static void ISR_Pit(void)
{
    static unsigned long debounceCounter = DEBOUNCE_TIME;
    unsigned long pisr = 0;

    // Read the PISR
    pisr = PIT_GetStatus() & AT91C_PITC_PITS;

    if (pisr != 0) {

        // Read the PIVR. It acknowledges the IT
        PIT_GetPIVR();
    }

    // Button released
    if (PIO_Get(&pinWakeUp)) {

        debounceCounter = DEBOUNCE_TIME;
    }
    // Button still pressed
    else {

        debounceCounter--;
    }

    // End of debounce time
    if (debounceCounter == 0) {

        debounceCounter = DEBOUNCE_TIME;
        PIT_DisableIT();
        AT91C_BASE_PITC->PITC_PIMR &= ~AT91C_PITC_PITEN;
        COMPOSITEDDriver_RemoteWakeUp();
    }
}

//------------------------------------------------------------------------------
/// Interrupt service routine for the system tick. Debounces the wake-up pin input.
//------------------------------------------------------------------------------
void SysTick_Handler(void)
{
    // Button released
    if (PIO_Get(&pinWakeUp)) 
    {

        debounceCounter = DEBOUNCE_TIME;
    }
    // Button still pressed
    else 
    {

        debounceCounter--;
    }

    // End of debounce time
    if (debounceCounter == 0) 
    {

        // Disable debounce timer
        SysTick_Configure(1, BOARD_MCK/1000, 0);

        debounceCounter = DEBOUNCE_TIME;
        HIDDMouseDriver_RemoteWakeUp();
    }
}

//updates position value if turning clockwise
void ENCODER_ISR_UP (const Pin *encoder_pin_cw )
{
//only updates on change from high to low
    if(!PIO_Get(encoder_pin_cw)){
        encoder_position_output++;
    }
}

int Accel_Z_ST(void)
{
	char value[2];
	
	while(!PIO_Get(&(accIntPins[0]))){nop();} // wait for data ready pin
	ReadAccelData(0x2C|(1<<7), value, 2); // ST chip
	return ((signed char)value[1]<<8)|value[0];
}

void usb_isr_vbus(const Pin *pin) {
    // Check current level on VBus
    if (PIO_Get(&pin_usb_detect)) {
        USBD_Connect();
    } else {
        USBD_Disconnect();
    }
}

//------------------------------------------------------------------------------
/// Interrupt service routine for the remote wake-up pin. Starts the debouncing
/// sequence.
//------------------------------------------------------------------------------
static void WakeUpHandler(const Pin *pin)
{
    TRACE_DEBUG("Wake-up handler\n\r");

    // Check current level on the remote wake-up pin
    if (!PIO_Get(&pinWakeUp)) {

        ConfigurePit();
    }
}

static void AccelCallback(void)
{
#ifdef STACCEL
	char value[6];
	while(!PIO_Get(&(accIntPins[0]))){nop();} // wait for data ready pin
	ReadAccelData(0x28|(1<<7),value,6); // ST chip
	g_AccelX = ((signed char)value[1]<<8)|value[0];
	g_AccelY = ((signed char)value[3]<<8)|value[2];
	g_AccelZ = ((signed char)value[5]<<8)|value[4];
#else
	char value[3];
	if(g_idle) return;
	while(!PIO_Get(&(accIntPins[0]))){nop();} // wait for data ready pin
	ReadAccelData(0x6,value,3);
	g_AccelX = (signed char)value[0];
	g_AccelY = (signed char)value[1];
	g_AccelZ = (signed char)value[2];
#endif
}

//------------------------------------------------------------------------------
/// Configures the VBus pin to trigger an interrupt when the level on that pin
/// changes.
//------------------------------------------------------------------------------
static void VBus_Configure( void ) {
  // Configure PIO
  PIO_Configure(&pinVbus, 1);
  PIO_ConfigureIt(&pinVbus, ISR_Vbus);
  PIO_EnableIt(&pinVbus);

  // Check current level on VBus
  if (PIO_Get(&pinVbus))
    // if VBUS present, force the connect
    USBD_Connect();          
}

/**
 * PIO interrupt service routine. Checks if the smartcard has been connected
 * or disconnected.
 */
static void ISR_PioSmartCard(const Pin *pPin)
{
	/*  Check all pending interrupts */
	if ((pinSmartCard.pio->PIO_ISR & pinSmartCard.mask) != 0) {
		/*  Check current level on pin */
		if (PIO_Get(&pinSmartCard ) == 0)
			printf("-I- Smartcard inserted\n\r");
		else
			printf("-I- Smartcard removed\n\r");
	}
}

static void prvVBusISRHandler( void )
{
    const Pin xVBusPin = PIN_USB_VBUS;

    /* Check current level on VBus to detect a connect/disconnect. */
    if( PIO_Get( &xVBusPin ) != 0 ) {
        USBD_Connect();
    } else {
        USBD_Disconnect();
    }
}

//------------------------------------------------------------------------------
/// PIO interrupt service routine. Checks if the smartcard has been connected
/// or disconnected.
//------------------------------------------------------------------------------
static void ISR_PioSmartCard(const Pin *pPin)
{
    // Check current level on pin
    if (PIO_Get(&pinSmartCard) == 0) {
        printf("-H- Insert\n\r");
        CCID_Insertion();
    } else {
        printf("-H- Removal\n\r");
        CCID_Removal();
    }
}

//------------------------------------------------------------------------------
/// Detect if SD card is connected
//------------------------------------------------------------------------------
static unsigned char CardIsConnected(unsigned char slot)
{
    if (slot == 0) {
#if defined(BOARD_SD_PIN_CD)
        PIO_Configure(&pinCardDetect, 1);
        return PIO_Get(&pinCardDetect) ? 0 : 1;
#else
        return 1;
#endif
    }
    if (slot == 1) {
#if defined(BOARD_SD_MCI1_PIN_CD)
        PIO_Configure(&pinCardDetect1, 1);
        return PIO_Get(&pinCardDetect1) ? 0 : 1;
#else
        return 1;
#endif
    }
    
    return 0;
}

void AccelCalibration(void)
{
#ifdef STACCEL	
	return;
#else
	char value[9];
	short avgOffset[3];
	int i,j;
	
	g_idle = 1;	// put the callback funciton on idle so it doesn't interrupt
	// set the Accelerometer to measurement mode
	value[0] = 5;
	WriteAccelData(0x16, value, 1);
	
	// clear out the old calibration values first!!!!!!!!
	g_calValues[0] = 0;
	g_calValues[1] = 0;
	g_calValues[2] = 0;
	value[0] = value[1] = value[2] = value[3] = value[4] = value[5] = 0;
	WriteAccelData(0x10, value, 6);
	usleep(200);
	
	for(j=0;j<10;j++){
		// get a set of readings from the Accelerometer
		while(!PIO_Get(&(accIntPins[0]))){nop();} // wait for data ready pin
		ReadAccelData(0x0,value,9);			// read in 9 bytes for both 10bit and 8bit
	
		for(i=0;i<3;i++){
			avgOffset[i] = value[i*2+1]<<8;
			avgOffset[i] |= value[i*2];
			if(avgOffset[i] > 512) avgOffset[i] -=1024;
			
			g_calValues[i] += avgOffset[i];	// sum up values
		}
		usleep(100000);
	}

	// take the average
	g_calValues[0] /= 10;
	g_calValues[1] /= 10;
	g_calValues[2] /= 10;
	
	// multiply the offsets by 2, stated in the datasheet unsure why has to do with 1/2 LSB
	g_calValues[0] = -g_calValues[0]*2;
	g_calValues[1] = -g_calValues[1]*2;
	g_calValues[2] = (64 - g_calValues[2])*2;
	
	// write data to offset register	
	AccelSetCalibration();
	g_idle = 0;	// turn back on the callback
#endif
}

//------------------------------------------------------------------------------
/// Checks if the device is write protected.
/// \return 1 if protected.
//------------------------------------------------------------------------------
static unsigned char CardIsProtected(unsigned char slot)
{
    if (slot == 0) {
#ifdef BOARD_SD_PIN_WP
        PIO_Configure(&pinMciWriteProtect, 1);
        return (PIO_Get(&pinMciWriteProtect) != 0);
#else
        return 0;
#endif
    }
    
    if (slot == 1) {
#ifdef BOARD_SD_MCI1_PIN_WP
        PIO_Configure(&pinMciWriteProtect1, 1);
        return (PIO_Get(&pinMciWriteProtect1) != 0);
#else
        return 0;
#endif
    }
    
    return 0;
}

//-----------------------------------------------------------------------------
/// Monitor keyboard buttons & Update key status in HID driver
//-----------------------------------------------------------------------------
static void HIDDKeyboardProcessKeys(void)
{
    unsigned int i;
    unsigned char pressedKeys[NUM_KEYS];
    unsigned char pressedKeysSize = 0;
    unsigned char releasedKeys[NUM_KEYS];
    unsigned char releasedKeysSize = 0;
    
    // Monitor buttons
    for (i=0; i < PIO_LISTSIZE(pinsPushButtons); i++) {
    
        // Check if button state has changed
        unsigned char isButtonPressed = PIO_Get(&(pinsPushButtons[i]));
        if (isButtonPressed != keyStatus[i]) {
    
            // Update button state
            if (!isButtonPressed) {
    
                // Key has been pressed
                TRACE_INFO("-I- Key %u has been pressed\n\r", i);
                keyStatus[i] = 0;
                pressedKeys[pressedKeysSize] = keyCodes[i];
                pressedKeysSize++;
                HIDDKeyboardDriver_RemoteWakeUp();
            }
            else {
    
                // Key has been released
                TRACE_INFO("-I- Key %u has been released\n\r", i);
                keyStatus[i] = 1;
                releasedKeys[releasedKeysSize] = keyCodes[i];
                releasedKeysSize++;
            }
        }
    }
    
    // Update key status in the HID driver if necessary
    if ((pressedKeysSize != 0) || (releasedKeysSize != 0)) {
    
        unsigned char status;

        do {
        
            status = HIDDKeyboardDriver_ChangeKeys(pressedKeys,
                                                   pressedKeysSize,
                                                   releasedKeys,
                                                   releasedKeysSize);
        }
        while (status != USBD_STATUS_SUCCESS);
    }
}

/**
 * Monitor keyboard buttons & Update key status in HID driver
 */
static void HIDDKeyboardProcessKeys(void)
{
    uint32_t i;
    uint8_t pressedKeys[NUM_KEYS];
    uint8_t pressedKeysSize = 0;
    uint8_t releasedKeys[NUM_KEYS];
    uint8_t releasedKeysSize = 0;

    /* Monitor buttons */
    for (i=0; i < PIO_LISTSIZE(pinsPushButtons); i++) {

        /* Check if button state has changed */
        uint8_t isButtonPressed = PIO_Get(&(pinsPushButtons[i]));
        if (isButtonPressed != keyStatus[i]) {

            /* Update button state */
            if (!isButtonPressed) {

                /* Key has been pressed */
                TRACE_INFO("-I- Key %u has been pressed\n\r", (unsigned int)i);
                keyStatus[i] = 0;
                pressedKeys[pressedKeysSize] = keyCodes[i];
                pressedKeysSize++;
                HIDDKeyboard_RemoteWakeUp();
            }
            else {

                /* Key has been released */
                TRACE_INFO("-I- Key %u has been released\n\r", (unsigned int)i);
                keyStatus[i] = 1;
                releasedKeys[releasedKeysSize] = keyCodes[i];
                releasedKeysSize++;
            }
        }
    }

    /* Update key status in the HID driver if necessary */
    if ((pressedKeysSize != 0) || (releasedKeysSize != 0)) {

        uint8_t status;

        do {

            status = HIDDKeyboard_ChangeKeys(pressedKeys,
                                             pressedKeysSize,
                                             releasedKeys,
                                             releasedKeysSize);
        }
        while (status != USBD_STATUS_SUCCESS);
    }
}