Merge remote-tracking branch 'stefanha/trivial-patches' into staging

    }

    l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gte)

                        * le64_to_cpu(header.granularity);

    if (l1_entry_sectors <= 0) {

    if (l1_entry_sectors == 0) {

        return -EINVAL;

    }

    l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)

# Print a helpful header at the top of config.log

echo "# QEMU configure log $(date)" >> config.log

echo "# produced by $0 $*" >> config.log

printf "# Configured with:" >> config.log

printf " '%s'" "$0" "$@" >> config.log

echo >> config.log

echo "#" >> config.log

compile_object() {

done

# OS specific

# Using uname is really, really broken.  Once we have the right set of checks

# we can eliminate it's usage altogether

# we can eliminate its usage altogether.

cc="${CC-${cross_prefix}gcc}"

ar="${AR-${cross_prefix}ar}"

fi

##########################################

# check if the compiler defines offsetof

need_offsetof=yes

cat > $TMPC << EOF

#include <stddef.h>

int main(void) { struct s { int f; }; return offsetof(struct s, f); }

EOF

if compile_prog "" "" ; then

    need_offsetof=no

fi

# spice probe

if test "$spice" != "no" ; then

  cat > $TMPC << EOF

if test "$tcg_interpreter" = "yes" ; then

  echo "CONFIG_TCG_INTERPRETER=y" >> $config_host_mak

fi

if test "$need_offsetof" = "yes" ; then

  echo "CONFIG_NEED_OFFSETOF=y" >> $config_host_mak

fi

if test "$fdatasync" = "yes" ; then

  echo "CONFIG_FDATASYNC=y" >> $config_host_mak

fi

    uint8_t idx;

    /* parse header line: width, height, #colors, #chars */

    if (sscanf(xpm[line], "%d %d %d %d", &width, &height, &colors, &chars) != 4) {

    if (sscanf(xpm[line], "%u %u %u %u",

               &width, &height, &colors, &chars) != 4) {

        fprintf(stderr, "%s: header parse error: \"%s\"\n",

                __FUNCTION__, xpm[line]);

        return NULL;

cards which are shared with the client machine the emulator is running on, or

the cards could be pure software constructs.

The emulator is structured to allow multiple replacable or additional pieces,

The emulator is structured to allow multiple replaceable or additional pieces,

so it can be easily modified for future requirements. The primary envisioned

modifications are:

--------------------

Replacing the Socket Based Virtual Reader Interface.

The current implementation contains a replacable module vscclient.c. The

The current implementation contains a replaceable module vscclient.c. The

current vscclient.c implements a sockets interface to the virtual ccid reader

on the guest. CCID commands that are pertinent to emulation are passed

across the socket, and their responses are passed back along that same socket.

the emulator.

An application that wants to use the virtual reader can replace vscclient.c

with it's own implementation that connects to it's own CCID reader.  The calls

with its own implementation that connects to its own CCID reader.  The calls

that the CCID reader can call are:

      VReaderList * vreader_get_reader_list();

      VReader * vreader_list_get_reader(VReaderListEntry *)

  This function returns the reader stored in the reader List entry. Caller gets

  a new reference to a reader. The caller must free it's reference when it is

  a new reference to a reader. The caller must free its reference when it is

  finished with vreader_free().

      void vreader_free(VReader *reader);

   This function frees a reference to a reader. Reader's are reference counted

   This function frees a reference to a reader. Readers are reference counted

   and are automatically deleted when the last reference is freed.

      void vreader_list_delete(VReaderList *list);

      VReaderStatus vreader_power_on(VReader *reader, char *atr, int *len);

  This functions simulates a card power on. Virtual cards do not care about

  This function simulates a card power on. A virtual card does not care about

  the actual voltage and other physical parameters, but it does care that the

  card is actually on or off. Cycling the card causes the card to reset. If

  the caller provides enough space, vreader_power_on will return the ATR of

                                       unsigned char *receive_buf,

                                       int receive_buf_len);

  This functions send a raw apdu to a card and returns the card's response.

  This function sends a raw apdu to a card and returns the card's response.

  The CCID front end should return the response back. Most of the emulation

  is driven from these APDUs.

         VCardStatus vcard_add_applet(VCard *card, VCardApplet *applet);

  Add an applet onto the list of applets attached to the card. Once an applet

  has been added, it can be selected by it's aid, and then commands will be

  routed to it VCardProcessAPDU function. This function adopts the applet the

  passed int applet. Note: 2 applets with the same AID should not be added to

  the same card. It's permissible to add more than one applet. Multiple applets

  has been added, it can be selected by its AID, and then commands will be

  routed to it VCardProcessAPDU function. This function adopts the applet that

  is passed into it. Note: 2 applets with the same AID should not be added to

  the same card. It is permissible to add more than one applet. Multiple applets

  may have the same VCardPRocessAPDU entry point.

The certs and keys should be attached to private data associated with one or

         VCard7816Status vcard_emul_login(VCard *card, unsigned char *pin,

                                          int pin_len);

    This function logins into the card and return the standard 7816 status

    This function logs into the card and returns the standard 7816 status

    word depending on the success or failure of the call.

         void vcard_emul_delete_key(VCardKey *key);

      cert_len, and keys are all arrays of length cert_count. These are the

      the same of the parameters xxxx_card_init() accepts.

   Finally the card is associated with it's reader by the call:

   Finally the card is associated with its reader by the call:

            VReaderStatus vreader_insert_card(VReader *vreader, VCard *vcard);

    static uint64_t time2[2] = {0};

#endif

    /* Call tick_timer event handler, it will update it's tcntb and icntb */

    /* Call tick_timer event handler, it will update its tcntb and icntb. */

    exynos4210_ltick_timer_event(&s->tick_timer);

    /* get tick_timer cnt */