sci_osd.c

IBM source for pallas/vulcan/vesta

SCI_ERROR sci_osd_read (ULONG sci_id,
                        UCHAR *p_buffer,
                        ULONG num_bytes,
                        ULONG *p_bytes_read,
                        ULONG flags
)
{
    SCI_ERROR rc = SCI_ERROR_OK;
    ULONG k_state;
    ULONG sci_bytes;
    INT block = 0;

    PDEBUG("card[%d] enter\n", (UINT) sci_id);

    if (sci_driver_init != 1)
    {
        rc = SCI_ERROR_DRIVER_NOT_INITIALIZED;
    }
    else if (sci_osi_is_card_activated(sci_id) != 1)
    {
        rc = SCI_ERROR_CARD_NOT_ACTIVATED;
    }
    else if((sci_id >= SCI_NUMBER_OF_CONTROLLERS) || 
            (p_buffer  == 0) ||
            (num_bytes == 0) ||
            (p_bytes_read == 0))
    {
        rc = SCI_ERROR_PARAMETER_OUT_OF_RANGE;
    }
    else
    {
        sci_cb[sci_id].read_flags = flags;
        //block = 0;
        (*p_bytes_read) = 0;

        if((flags & SCI_SYNC) == SCI_SYNC)
        {
            sci_atom_set_rx_threshold_interrupts(sci_id, num_bytes);
            /* wait for TX to complete */
            if(sci_cb[sci_id].state == SCI_STATE_TX)
            {
                block = 1;
            }
            else
            {
                /* we want any amount of data */
                if((flags & SCI_DATA_ANY) == SCI_DATA_ANY)
                {
                    if((sci_cb[sci_id].p_read == sci_cb[sci_id].p_write))
                    {
                        /* but no data has been received, so block */
                        block = 1;
                    }
                }
                else
                {
                    if((sci_cb[sci_id].rx_complete != 1) &&
                      ((sci_cb[sci_id].p_write - sci_cb[sci_id].p_read) < num_bytes))
                    {
                        /* we want all the data and RX is not complete, so block */
                        sci_cb[sci_id].bytes_expected = (INT) num_bytes;
                        block = 1;
                    }
                }
            }

            if(block == 1)
            {
                k_state = os_enter_critical_section();
                if((sci_cb[sci_id].rx_complete == 0) &&
                   (sci_osi_is_card_activated(sci_id) == 1))
                {
                    sci_cb[sci_id].waiting = 1;
                    if(interruptible_sleep_on_timeout(sci_wait_q[sci_id],
                                                      SCI_TIMEOUT_MS/10) == 0)
                    {
                        if(sci_cb[sci_id].waiting == 0)
                        {
                            /* suspend timed-out, but resume was called- OS problem */
                            sci_cb[sci_id].error = SCI_ERROR_KERNEL_FAIL;
                        }
                        else
                        {
                            /* suspend timed-out, resume was not called- SCI or transmission problem */
                            sci_cb[sci_id].error = SCI_ERROR_TRANSACTION_ABORTED;
                        }
                    }
                }
                os_leave_critical_section(k_state);
            }
        }

        k_state = os_enter_critical_section();
        /* copy any available data from private buffer */
        if(sci_cb[sci_id].p_read < sci_cb[sci_id].p_write)
        {
            if(num_bytes > 0)
            {
                sci_bytes = (sci_cb[sci_id].p_write - sci_cb[sci_id].p_read);
                if(sci_bytes > num_bytes)
                {
                    sci_bytes = num_bytes;
                }
                memcpy((void *)p_buffer,
                       (const char *)sci_cb[sci_id].p_read,
                       sci_bytes);
                sci_cb[sci_id].p_read += sci_bytes;
                (*p_bytes_read) += sci_bytes;
            }
        }
        rc = sci_cb[sci_id].error;
        sci_cb[sci_id].error = SCI_ERROR_OK;
        os_leave_critical_section(k_state);
    }

    if(rc != SCI_ERROR_OK)
    {
        PDEBUG("card[%d] error=%d\n", (UINT) sci_id, rc);
    }

    PDEBUG("card[%d] exit\n", (UINT) sci_id);

    return(rc);
}

/****************************************************************************
** Function:    sci_osd_reset
**
** Purpose:     Initiate a reset (enter atr state).
**
** Parameters:  sci_id: zero-based number to identify smart card controller
**
** Returns:     SCI_ERROR_OK: if successful
**              SCI_ERROR_DRIVER_NOT_INITIALIZED: if no successful call to
**                  sci_init() has been made
**              SCI_ERROR_PARAMETER_OUT_OF_RANGE:  if sci_id is invalid
**              SCI_ERROR_CARD_NOT_PRESENT: if no Smart Card is
**                  present in the reader
**              SCI_ERROR_ATR_PENDING: if a reset has already been initiated
**                  and an ATR is still pending
****************************************************************************/
SCI_ERROR sci_osd_reset(ULONG sci_id)
{
    SCI_PARAMETERS sci_parameters;
    SCI_RESET_TYPE reset_type = COLD;
    SCI_ERROR rc = SCI_ERROR_OK;
    ULONG k_state;

    PDEBUG("card[%d] enter\n", (UINT) sci_id);

    if(sci_driver_init == 1)
    {
        if(sci_id < SCI_NUMBER_OF_CONTROLLERS)
        {
            if(sci_atom_is_card_present(sci_id) == 1)
            {
                k_state = os_enter_critical_section();
                /* initialize control block values */
                if(sci_cb[sci_id].state == SCI_STATE_DEAC)
                {
                    reset_type = COLD;
                }
                else
                {
                    reset_type = WARM;
                    if(sci_cb[sci_id].waiting == 1)
                    {
                        sci_cb[sci_id].waiting = 0;
                        wake_up_interruptible(sci_wait_q[sci_id]);
                        sci_cb[sci_id].rx_complete = 1;
                    }
                }
                sci_cb[sci_id].error = SCI_ERROR_OK;
                /* reset pointers to start of buffer */
                sci_cb[sci_id].p_read  = sci_cb[sci_id].buffer;
                sci_cb[sci_id].p_write = sci_cb[sci_id].buffer;

                /* set default parameter values based on mode */
                sci_parameters.T   = SCI_ATR_T;
                sci_parameters.f   = SCI_ATR_F;
                sci_parameters.ETU = SCI_ATR_ETU;
                sci_parameters.WWT = SCI_ATR_WWT;
                if(sci_cb[sci_id].sci_modes.emv2000 == 1)
                {
                   sci_parameters.CWT = SCI_ATR_AWT;
                }
                else
                {
                   sci_parameters.CWT = SCI_ATR_CWT;
                }
                sci_parameters.BWT = SCI_ATR_BWT;
                sci_parameters.EGT = SCI_ATR_EGT;
                sci_parameters.clock_stop_polarity 
                                   = SCI_CLOCK_STOP_DISABLED;
                sci_parameters.check = SCI_ATR_CHECK;
                sci_parameters.P = SCI_ATR_P;
                sci_parameters.I = SCI_ATR_I;
                sci_parameters.U = SCI_ATR_U;
                rc = sci_osi_set_para(sci_id, &sci_parameters);

                /* start atr or rx state */
                sci_osi_rx_start(sci_id);
                sci_atom_clear_UICSR(sci_id);
                os_leave_critical_section(k_state);

                sci_atom_HW_reset(sci_id, reset_type);
            }
            else
            {
                rc = SCI_ERROR_CARD_NOT_PRESENT;
            }
        }
        else
        {
            rc = SCI_ERROR_PARAMETER_OUT_OF_RANGE;
        }
    }
    else
    {
        rc = SCI_ERROR_DRIVER_NOT_INITIALIZED;
    }

    if(rc != SCI_ERROR_OK)
    {
        PDEBUG("card[%d] error=%d\n", (UINT) sci_id, rc);
    }
    PDEBUG("card[%d] exit\n", (UINT) sci_id);

    return(rc);
}

/*****************************************************************************
** Function:    sci_osd_deactivate
**
** Purpose:     Initiate a deactivation (enter deac state).
**
** Parameters:  sci_id: zero-based number to identify smart card controller
**
** Returns:     SCI_ERROR_OK: if successful
**              SCI_ERROR_DRIVER_NOT_INITIALIZED: if no successful call to
**                  sci_init() has been made
**              SCI_ERROR_PARAMETER_OUT_OF_RANGE: if sci_id is invalid
**              SCI_ERROR_CARD_NOT_ACTIVATED: if card is not activated
*****************************************************************************/
SCI_ERROR sci_osd_deactivate(ULONG sci_id)
{
    ULONG k_state;
    SCI_ERROR rc = SCI_ERROR_OK;

    PDEBUG("card[%d] enter\n", (UINT) sci_id);

    if(sci_driver_init == 1)
    {
        if(sci_id < SCI_NUMBER_OF_CONTROLLERS)
        {
            if(sci_cb[sci_id].state != SCI_STATE_DEAC)
            {
                k_state = os_enter_critical_section();
                /* abort any current transactions                         */
                /* assign abort error code if one is not already assigned */
                if(sci_cb[sci_id].waiting == 1)
                {
                    sci_cb[sci_id].waiting = 0;
                    wake_up_interruptible(sci_wait_q[sci_id]);
                    //os_release_mutex(sci_cb[sci_id].mutex);
                    sci_cb[sci_id].error = SCI_ERROR_TRANSACTION_ABORTED;
                    sci_cb[sci_id].rx_complete = 1;
                }
                sci_atom_deactivate(sci_id);
                sci_cb[sci_id].state = SCI_STATE_DEAC;
                os_leave_critical_section(k_state);
            }
        }
        else
        {
            rc = SCI_ERROR_PARAMETER_OUT_OF_RANGE;
        }
    }
    else
    {
        rc = SCI_ERROR_DRIVER_NOT_INITIALIZED;
    }

    if(rc != SCI_ERROR_OK)
    {
        PDEBUG("card[%d] error=%d\n", (UINT) sci_id, rc);
    }
    PDEBUG("card[%d] exit\n", (UINT) sci_id);

    return(rc);
}