path: root/usr/src/common/ccid/atr.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2019, Joyent, Inc.
 */

/*
 * ATR parsing routines shared between userland (ccidadm) and the kernel (CCID
 * driver)
 */

#include "atr.h"
#include <sys/debug.h>
#include <sys/sysmacros.h>

#ifdef	_KERNEL
#include <sys/inttypes.h>
#include <sys/sunddi.h>
#include <sys/kmem.h>
#else
#include <inttypes.h>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#endif

/*
 * The ATR must have at least 2 bytes and then may have up to 33 bytes. The
 * first byte is always TS and the second required byte is T0.
 */
#define	ATR_TS_IDX	0
#define	ATR_T0_IDX	1

/*
 * There are two valid values for TS. It must either be 0x3F or 0x3B. This is
 * required per ISO/IEC 7816-3:2006 section 8.1.
 */
#define	ATR_TS_INVERSE	0x3F
#define	ATR_TS_DIRECT	0x3B

/*
 * After TS, each word is used to indicate a combination of protocol and the
 * number of bits defined for that protocol. The lower nibble is treated as the
 * protocol. The upper nibble is treated to indicate which of four defined words
 * are present. These are usually referred to as TA, TB, TC, and TD. TD is
 * always used to indicate the next protocol and the number of bytes present for
 * that. T0 works in a similar way, except that it defines the number of
 * historical bytes present in its protocol section and then it refers to a set
 * of pre-defined global bytes that may be present.
 */
#define	ATR_TD_PROT(x)	((x) & 0x0f)
#define	ATR_TD_NBITS(x)	(((x) & 0xf0) >> 4)
#define	ATR_TA_MASK	0x1
#define	ATR_TB_MASK	0x2
#define	ATR_TC_MASK	0x4
#define	ATR_TD_MASK	0x8

#define	ATR_TA1_FTABLE(x)	(((x) & 0xf0) >> 4)
#define	ATR_TA1_DITABLE(x)	((x) & 0x0f)

#define	ATR_TA2_CANCHANGE(x)	(((x) & 0x80) == 0)
#define	ATR_TA2_HONORTA1(x)	(((x) & 0x10) == 0)
#define	ATR_TA2_PROTOCOL(x)	((x) & 0x0f)

/*
 * When the checksum is required in the ATR, each byte must XOR to zero.
 */
#define	ATR_CKSUM_TARGET	0

/*
 * Maximum number of historic ATR bytes. This is limited by the fact that it's a
 * 4-bit nibble.
 */
#define	ATR_HISTORICAL_MAX	15

/*
 * The maximum number of TA, TB, TC, and TD levels that can be encountered in a
 * given structure. In the best case, there are 30 bytes available (TS, T0, and
 * TCK use the others). Given that each one of these needs 4 bytes to be
 * represented, the maximum number of layers that can fit is seven.
 */
#define	ATR_TI_MAX	7

/*
 * Defined protocol values. See ISO/IEC 7816-3:2006 8.2.3 for this list.
 * Reserved values are noted but not defined.
 */
#define	ATR_PROTOCOL_T0		0
#define	ATR_PROTOCOL_T1		1

#define	ATR_T1_TB0_CWI(x)	((x) & 0x0f)
#define	ATR_T1_TB0_BWI(x)	(((x) & 0xf0) >> 4)
#define	ATR_T1_TC0_CRC(x)	(((x) & 0x01) != 0)

/*
 * T=2 and T=3 are reserved for future full-duplex operation.
 * T=4 is reserved for enhanced half-duplex character transmission.
 * T=5-13 are reserved for future use by ISO/IEC JTC 1/SC 17.
 * T=14 is for protocols not standardized by ISO/IEC JTC 1/SC 17.
 */
#define	ATR_PROTOCOL_T15	15

#define	ATR_T15_TA0_CLOCK(x)	(((x) & 0xc0) >> 6)
#define	ATR_T15_TA0_VOLTAGE(x)	((x) & 0x3f)

#define	ATR_T15_TB0_SPU_STANDARD(x)	(((x & 0x80)) != 0)

/*
 * Various definitions for the configuration of historical data. This comes from
 * ISO/IEC 7816-4:2013 Section 12.1.1.
 */

/*
 * The first historical byte is used to indicate the encoding of the data. Only
 * values 0x00, 0x80-0x8f are defined. All others are proprietary. 0x81-0x8f are
 * reserved for future use.
 */
#define	ATR_HIST_CAT_MAND_STATUS	0x00
#define	ATR_HIST_CAT_TLV_STATUS		0x80
#define	ATR_HIST_CAT_RFU_MIN		0x81
#define	ATR_HIST_CAT_RFU_MAX		0x8f

/*
 * From ISO/IEC 7816-3:2006 Section 8.3.
 *
 * The default value for Fi is 372 which is table entry 1. The default value for
 * Di is 1, which is table entry 1.
 */
#define	ATR_FI_DEFAULT_INDEX	1
#define	ATR_DI_DEFAULT_INDEX	1
#define	ATR_EXTRA_GUARDTIME_DEFAULT	0

/*
 * From ISO/IEC 7816-3:2006 Section 10.2.
 */
#define	ATR_T0_WI_DEFAULT	10

/*
 * From ISO/IEC 7816-3:2006 Section 11.4.3.
 */
#define	ATR_T1_CWI_DEFAULT	13

/*
 * From ISO/IEC 7816-3:2006 Section 11.4.3.
 */
#define	ATR_T1_BWI_DEFAULT	4

/*
 * From ISO/IEC 7816-3:2006 Section 11.4.2.
 */
#define	ATR_T1_IFSC_DEFAULT	32

/*
 * From ISO/IEC 7816-3:2006 Section 11.4.4
 */
#define	ATR_T1_CHECKSUM_DEFAULT	ATR_T1_CHECKSUM_LRC

/*
 * Definitions for PPS construction. These are derived from ISO/IEC 7816-3:2006
 * section 9, Protocol and parameters selection.
 */
#define	PPS_LEN_MIN	3	/* PPSS, PPS0, PCK */
#define	PPS_LEN_MAX	PPS_BUFFER_MAX
#define	PPS_PPSS_INDEX	0
#define	PPS_PPSS_VAL	0xff
#define	PPS_PPS0_INDEX	0x01
#define	PPS_PPS0_PROT(x)	((x) & 0x0f)
#define	PPS_PPS0_PPS1		(1 << 4)
#define	PPS_PPS0_PPS2		(1 << 5)
#define	PPS_PPS0_PPS3		(1 << 6)
#define	PPS_PPS1_SETVAL(f, d)	((((f) & 0x0f) << 4) | ((d) & 0x0f))

/*
 * This enum and subsequent structure is used to represent a single level of
 * 'T'. This includes the possibility for all three values to be set and records
 * the protocol.
 */
typedef enum atr_ti_flags {
	ATR_TI_HAVE_TA	= 1 << 0,
	ATR_TI_HAVE_TB	= 1 << 1,
	ATR_TI_HAVE_TC	= 1 << 2,
	ATR_TI_HAVE_TD	= 1 << 3
} atr_ti_flags_t;

typedef struct atr_ti {
	uint8_t		atrti_protocol;
	uint8_t		atrti_ti_val;
	uint8_t		atrti_td_idx;
	atr_ti_flags_t	atrti_flags;
	uint8_t		atrti_ta;
	uint8_t		atrti_tb;
	uint8_t		atrti_tc;
	uint8_t		atrti_td;
} atr_ti_t;

typedef enum atr_flags {
	ATR_F_USES_DIRECT	= 1 << 0,
	ATR_F_USES_INVERSE	= 1 << 1,
	ATR_F_HAS_CHECKSUM	= 1 << 2,
	ATR_F_VALID		= 1 << 3
} atr_flags_t;


struct atr_data {
	atr_flags_t	atr_flags;
	uint8_t		atr_nti;
	atr_ti_t	atr_ti[ATR_TI_MAX];
	uint8_t		atr_nhistoric;
	uint8_t		atr_historic[ATR_HISTORICAL_MAX];
	uint8_t		atr_cksum;
	uint8_t		atr_raw[ATR_LEN_MAX];
	uint8_t		atr_nraw;
};

/*
 * These tables maps the bit values for Fi from 7816-3:2006 section 8.3 Table 7.
 */
static uint_t atr_fi_valtable[16] = {
	372,		/* 0000 */
	372,		/* 0001 */
	558,		/* 0010 */
	744,		/* 0011 */
	1116,		/* 0100 */
	1488,		/* 0101 */
	1860,		/* 0110 */
	0,		/* 0111 */
	0,		/* 1000 */
	512,		/* 1001 */
	768,		/* 1010 */
	1024,		/* 1011 */
	1536,		/* 1100 */
	2048,		/* 1101 */
	0,		/* 1110 */
	0		/* 1111 */
};

static const char *atr_fi_table[16] = {
	"372",		/* 0000 */
	"372",		/* 0001 */
	"558",		/* 0010 */
	"744",		/* 0011 */
	"1116",		/* 0100 */
	"1488",		/* 0101 */
	"1860",		/* 0110 */
	"RFU",		/* 0111 */
	"RFU",		/* 1000 */
	"512",		/* 1001 */
	"768",		/* 1010 */
	"1024",		/* 1011 */
	"1536",		/* 1100 */
	"2048",		/* 1101 */
	"RFU",		/* 1110 */
	"RFU",		/* 1111 */
};

/*
 * This table maps the bit values for f(max) from 7816-3:2006 section 8.3
 * Table 7.
 */
static const char *atr_fmax_table[16] = {
	"4",		/* 0000 */
	"5",		/* 0001 */
	"6",		/* 0010 */
	"8",		/* 0011 */
	"12",		/* 0100 */
	"16",		/* 0101 */
	"20",		/* 0110 */
	"-",		/* 0111 */
	"-",		/* 1000 */
	"5",		/* 1001 */
	"7.5",		/* 1010 */
	"10",		/* 1011 */
	"15",		/* 1100 */
	"20",		/* 1101 */
	"-",		/* 1110 */
	"-",		/* 1111 */
};

/*
 * This table maps the bit values for Di from 7816-3:2006 section 8.3 Table 8.
 */
static uint_t atr_di_valtable[16] = {
	0,		/* 0000 */
	1,		/* 0001 */
	2,		/* 0010 */
	4,		/* 0011 */
	8,		/* 0100 */
	16,		/* 0101 */
	32,		/* 0110 */
	64,		/* 0111 */
	12,		/* 1000 */
	20,		/* 1001 */
	0,		/* 1010 */
	0,		/* 1011 */
	0,		/* 1100 */
	0,		/* 1101 */
	0,		/* 1110 */
	0		/* 1111 */
};

static const char *atr_di_table[16] = {
	"RFU",		/* 0000 */
	"1",		/* 0001 */
	"2",		/* 0010 */
	"4",		/* 0011 */
	"8",		/* 0100 */
	"16",		/* 0101 */
	"32",		/* 0110 */
	"64",		/* 0111 */
	"12",		/* 1000 */
	"20",		/* 1001 */
	"RFU",		/* 1010 */
	"RFU",		/* 1011 */
	"RFU",		/* 1100 */
	"RFU",		/* 1101 */
	"RFU",		/* 1110 */
	"RFU",		/* 1111 */
};

/*
 * This table maps the bit values for the clock stop indicator from 7816-3:2006
 * section 8.3 Table 9.
 */
static const char *atr_clock_table[4] = {
	"disallowed",		/* 00 */
	"signal low",		/* 01 */
	"signal high",		/* 10 */
	"signal low or high"	/* 11 */
};

uint_t
atr_fi_index_to_value(uint8_t val)
{
	if (val >= ARRAY_SIZE(atr_fi_valtable)) {
		return (0);
	}

	return (atr_fi_valtable[val]);
}

const char *
atr_fi_index_to_string(uint8_t val)
{
	if (val >= ARRAY_SIZE(atr_fi_table)) {
		return ("<invalid>");
	}

	return (atr_fi_table[val]);
}

const char *
atr_fmax_index_to_string(uint8_t val)
{
	if (val >= ARRAY_SIZE(atr_fmax_table)) {
		return ("<invalid>");
	}

	return (atr_fmax_table[val]);
}

uint_t
atr_di_index_to_value(uint8_t val)
{
	if (val >= ARRAY_SIZE(atr_di_valtable)) {
		return (0);
	}

	return (atr_di_valtable[val]);
}
const char *
atr_di_index_to_string(uint8_t val)
{
	if (val >= ARRAY_SIZE(atr_di_table)) {
		return ("<invalid>");
	}

	return (atr_di_table[val]);
}

const char *
atr_clock_stop_to_string(atr_clock_stop_t val)
{
	if (val >= ARRAY_SIZE(atr_clock_table)) {
		return ("<invalid>");
	}

	return (atr_clock_table[val]);
}

const char *
atr_protocol_to_string(atr_protocol_t prot)
{
	if (prot == ATR_P_NONE) {
		return ("none");
	}

	if ((prot & ATR_P_T0) == ATR_P_T0) {
		return ("T=0");
	} else if ((prot & ATR_P_T1) == ATR_P_T1) {
		return ("T=1");
	} else {
		return ("T=0, T=1");
	}
}

const char *
atr_convention_to_string(atr_convention_t conv)
{
	if (conv == ATR_CONVENTION_DIRECT) {
		return ("direct");
	} else if (conv == ATR_CONVENTION_INVERSE) {
		return ("inverse");
	} else {
		return ("<invalid convention>");
	}
}

const char *
atr_strerror(atr_parsecode_t code)
{
	switch (code) {
	case ATR_CODE_OK:
		return ("ATR parsed successfully");
	case ATR_CODE_TOO_SHORT:
		return ("Specified buffer too short");
	case ATR_CODE_TOO_LONG:
		return ("Specified buffer too long");
	case ATR_CODE_INVALID_TS:
		return ("ATR has invalid TS byte value");
	case ATR_CODE_OVERRUN:
		return ("ATR data requires more bytes than provided");
	case ATR_CODE_UNDERRUN:
		return ("ATR data did not use all provided bytes");
	case ATR_CODE_CHECKSUM_ERROR:
		return ("ATR data did not checksum correctly");
	case ATR_CODE_INVALID_TD1:
		return ("ATR data has invalid protocol in TD1");
	default:
		return ("Unknown Parse Code");
	}
}

static uint_t
atr_count_cbits(uint8_t x)
{
	uint_t ret = 0;

	if (x & ATR_TA_MASK)
		ret++;
	if (x & ATR_TB_MASK)
		ret++;
	if (x & ATR_TC_MASK)
		ret++;
	if (x & ATR_TD_MASK)
		ret++;
	return (ret);
}

/*
 * Parse out ATR values. Focus on only parsing it and not interpreting it.
 * Interpretation should be done in other functions that can walk over the data
 * and be more protocol-aware.
 */
atr_parsecode_t
atr_parse(const uint8_t *buf, size_t len, atr_data_t *data)
{
	uint_t nhist, cbits, ncbits, idx, Ti, prot;
	uint_t ncksum = 0;
	atr_ti_t *atp;

	/*
	 * Zero out data in case someone's come back around for another loop on
	 * the same data.
	 */
	bzero(data, sizeof (atr_data_t));

	if (len < ATR_LEN_MIN) {
		return (ATR_CODE_TOO_SHORT);
	}

	if (len > ATR_LEN_MAX) {
		return (ATR_CODE_TOO_LONG);
	}

	if (buf[ATR_TS_IDX] != ATR_TS_INVERSE &&
	    buf[ATR_TS_IDX] != ATR_TS_DIRECT) {
		return (ATR_CODE_INVALID_TS);
	}

	bcopy(buf, data->atr_raw, len);
	data->atr_nraw = len;

	if (buf[ATR_TS_IDX] == ATR_TS_DIRECT) {
		data->atr_flags |= ATR_F_USES_DIRECT;
	} else {
		data->atr_flags |= ATR_F_USES_INVERSE;
	}

	/*
	 * The protocol of T0 is the number of historical bits present.
	 */
	nhist = ATR_TD_PROT(buf[ATR_T0_IDX]);
	cbits = ATR_TD_NBITS(buf[ATR_T0_IDX]);
	idx = ATR_T0_IDX + 1;
	ncbits = atr_count_cbits(cbits);

	/*
	 * Ti is used to track the current iteration of T[A,B,C,D] that we are
	 * on, as the ISO/IEC standard suggests. The way that values are
	 * interpreted depends on the value of Ti.
	 *
	 * When Ti is one, TA, TB, and TC represent global properties. TD's
	 * protocol represents the preferred protocol.
	 *
	 * When Ti is two, TA, TB, and TC also represent global properties.
	 * However, TC only has meaning if the protocol is T=0.
	 *
	 * When Ti is 15, it indicates more global properties.
	 *
	 * For all other values of Ti, the meaning depends on the protocol in
	 * question and they are all properties specific to that protocol.
	 */
	Ti = 1;
	/*
	 * Initialize prot to an invalid protocol to help us deal with the
	 * normal workflow and make sure that we don't mistakenly do anything.
	 */
	prot = UINT32_MAX;
	for (;;) {
		atp = &data->atr_ti[data->atr_nti];
		data->atr_nti++;
		ASSERT3U(data->atr_nti, <=, ATR_TI_MAX);

		/*
		 * Make sure that we have enough space to read all the cbits.
		 * idx points to the first cbit, which could also potentially be
		 * over the length of the buffer. This is why we subtract one
		 * from idx when doing the calculation.
		 */
		if (idx - 1 + ncbits >= len) {
			return (ATR_CODE_OVERRUN);
		}

		ASSERT3U(Ti, !=, 0);

		/*
		 * At the moment we opt to ignore reserved protocols.
		 */
		atp->atrti_protocol = prot;
		atp->atrti_ti_val = Ti;
		atp->atrti_td_idx = idx - 1;

		if (cbits & ATR_TA_MASK) {
			atp->atrti_flags |= ATR_TI_HAVE_TA;
			atp->atrti_ta = buf[idx];
			idx++;
		}

		if (cbits & ATR_TB_MASK) {
			atp->atrti_flags |= ATR_TI_HAVE_TB;
			atp->atrti_tb = buf[idx];
			idx++;
		}

		if (cbits & ATR_TC_MASK) {
			atp->atrti_flags |= ATR_TI_HAVE_TC;
			atp->atrti_tc = buf[idx];
			idx++;
		}

		if (cbits & ATR_TD_MASK) {
			atp->atrti_flags |= ATR_TI_HAVE_TD;
			atp->atrti_td = buf[idx];
			cbits = ATR_TD_NBITS(buf[idx]);
			prot = ATR_TD_PROT(buf[idx]);
			ncbits = atr_count_cbits(cbits);
			if (prot != 0)
				ncksum = 1;

			/*
			 * T=15 is not allowed in TD1 per 8.2.3.
			 */
			if (Ti == 1 && prot == 0xf)
				return (ATR_CODE_INVALID_TD1);

			idx++;
			/*
			 * Encountering TD means that once we take the next loop
			 * and we need to increment Ti.
			 */
			Ti++;
		} else {
			break;
		}
	}

	/*
	 * We've parsed all of the cbits. At this point, we should take into
	 * account all of the historical bits and potentially the checksum.
	 */
	if (idx - 1 + nhist + ncksum >= len) {
		return (ATR_CODE_OVERRUN);
	}

	if (idx + nhist + ncksum != len) {
		return (ATR_CODE_UNDERRUN);
	}

	if (nhist > 0) {
		data->atr_nhistoric = nhist;
		bcopy(&buf[idx], data->atr_historic, nhist);
	}

	if (ncksum > 0) {
		size_t i;
		uint8_t val;

		/*
		 * Per ISO/IEC 7816-3:2006 Section 8.2.5 the checksum is all
		 * bytes excluding TS. Therefore, we must start at byte 1.
		 */
		for (val = 0, i = 1; i < len; i++) {
			val ^= buf[i];
		}

		if (val != ATR_CKSUM_TARGET) {
			return (ATR_CODE_CHECKSUM_ERROR);
		}
		data->atr_flags |= ATR_F_HAS_CHECKSUM;
		data->atr_cksum = buf[len - 1];
	}

	data->atr_flags |= ATR_F_VALID;
	return (ATR_CODE_OK);
}

uint8_t
atr_fi_default_index(void)
{
	return (ATR_FI_DEFAULT_INDEX);
}

uint8_t
atr_di_default_index(void)
{
	return (ATR_DI_DEFAULT_INDEX);
}

/*
 * Parse the data to determine which protocols are supported in this atr data.
 * Based on this, users can come and ask us to fill in protocol information.
 */
atr_protocol_t
atr_supported_protocols(atr_data_t *data)
{
	uint_t i;
	atr_protocol_t prot;

	if ((data->atr_flags & ATR_F_VALID) == 0)
		return (ATR_P_NONE);

	/*
	 * Based on 8.2.3 of ISO/IEC 7816-3:2006, if TD1 is present, then that
	 * indicates the first protocol. However, if it is not present, then
	 * that implies that T=0 is the only supported protocol. Otherwise, all
	 * protocols are referenced in ascending order. The first entry in
	 * atr_ti refers to data from T0, so the protocol in the second entry
	 * would have the TD1 data.
	 */
	if (data->atr_nti < 2) {
		return (ATR_P_T0);
	}

	prot = ATR_P_NONE;
	for (i = 0; i < data->atr_nti; i++) {
		switch (data->atr_ti[i].atrti_protocol) {
		case ATR_PROTOCOL_T0:
			prot |= ATR_P_T0;
			break;
		case ATR_PROTOCOL_T1:
			prot |= ATR_P_T1;
			break;
		default:
			/*
			 * T=15 is not a protocol, and all other protocol values
			 * are currently reserved for future use.
			 */
			continue;
		}
	}

	/*
	 * It's possible we've found nothing specific in the above loop (for
	 * example, only T=15 global bits were found). In that case, the card
	 * defaults to T=0.
	 */
	if (prot == ATR_P_NONE)
		prot = ATR_P_T0;

	return (prot);
}

boolean_t
atr_params_negotiable(atr_data_t *data)
{
	/* If for some reason we're called with invalid data, assume it's not */
	if ((data->atr_flags & ATR_F_VALID) == 0)
		return (B_FALSE);


	/*
	 * Whether or not we're negotiable is in the second global page, so atr
	 * index 1. If TA2 is missing, then the card always is negotiable.
	 */
	if (data->atr_nti < 2 ||
	    (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) == 0) {
		return (B_TRUE);
	}

	if (ATR_TA2_CANCHANGE(data->atr_ti[1].atrti_ta)) {
		return (B_TRUE);
	}

	return (B_FALSE);
}

atr_protocol_t
atr_default_protocol(atr_data_t *data)
{
	uint8_t prot;

	if ((data->atr_flags & ATR_F_VALID) == 0)
		return (ATR_P_NONE);
	/*
	 * If we don't have an TA2 byte, then the system defaults to T=0.
	 */
	if (data->atr_nti < 2) {
		return (ATR_P_T0);
	}

	/*
	 * If TA2 is present, then it encodes the default protocol. Otherwise,
	 * we have to grab the protocol value from TD1, which is called the
	 * 'first offered protocol'.
	 */
	if ((data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) != 0) {
		prot = ATR_TA2_PROTOCOL(data->atr_ti[1].atrti_ta);
	} else {
		prot = data->atr_ti[1].atrti_protocol;
	}

	switch (prot) {
	case ATR_PROTOCOL_T0:
		return (ATR_P_T0);
	case ATR_PROTOCOL_T1:
		return (ATR_P_T1);
	default:
		return (ATR_P_NONE);
	}
}

uint8_t
atr_fi_index(atr_data_t *data)
{
	if (data->atr_nti < 1) {
		return (ATR_FI_DEFAULT_INDEX);
	}

	/*
	 * If TA is specified, it is present in TA1. TA2 may override its
	 * presence, so if it is here, check that first to determine whether or
	 * not we should check TA1.
	 */
	if (data->atr_nti >= 2 &&
	    (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) != 0) {
		if (!ATR_TA2_HONORTA1(data->atr_ti[1].atrti_ta)) {
			return (ATR_FI_DEFAULT_INDEX);
		}
	}

	if ((data->atr_ti[0].atrti_flags & ATR_TI_HAVE_TA) != 0) {
		return (ATR_TA1_FTABLE(data->atr_ti[0].atrti_ta));
	}

	return (ATR_FI_DEFAULT_INDEX);
}

uint8_t
atr_di_index(atr_data_t *data)
{
	if (data->atr_nti < 1) {
		return (ATR_DI_DEFAULT_INDEX);
	}

	/*
	 * If TA is specified, it is present in TA1. TA2 may override its
	 * presence, so if it is here, check that first to determine whether or
	 * not we should check TA1.
	 */
	if (data->atr_nti >= 2 &&
	    (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) != 0) {
		if (!ATR_TA2_HONORTA1(data->atr_ti[1].atrti_ta)) {
			return (ATR_DI_DEFAULT_INDEX);
		}
	}

	if ((data->atr_ti[0].atrti_flags & ATR_TI_HAVE_TA) != 0) {
		return (ATR_TA1_DITABLE(data->atr_ti[0].atrti_ta));
	}

	return (ATR_DI_DEFAULT_INDEX);
}

atr_convention_t
atr_convention(atr_data_t *data)
{
	if ((data->atr_flags & ATR_F_USES_DIRECT) != 0) {
		return (ATR_CONVENTION_DIRECT);
	}
	return (ATR_CONVENTION_INVERSE);
}

uint8_t
atr_extra_guardtime(atr_data_t *data)
{
	if ((data->atr_flags & ATR_F_VALID) == 0)
		return (ATR_EXTRA_GUARDTIME_DEFAULT);

	if (data->atr_nti >= 1 &&
	    (data->atr_ti[0].atrti_flags & ATR_TI_HAVE_TC) != 0) {
		return (data->atr_ti[0].atrti_tc);
	}

	return (ATR_EXTRA_GUARDTIME_DEFAULT);
}

uint8_t
atr_t0_wi(atr_data_t *data)
{
	if ((data->atr_flags & ATR_F_VALID) == 0)
		return (ATR_T0_WI_DEFAULT);

	/*
	 * This is stored in the optional global byte in TC2; however, it only
	 * applies to T=0.
	 */
	if (data->atr_nti >= 2 &&
	    data->atr_ti[1].atrti_protocol == ATR_PROTOCOL_T0 &&
	    (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TC) != 0) {
		return (data->atr_ti[1].atrti_tc);
	}

	return (ATR_T0_WI_DEFAULT);
}

uint8_t
atr_t1_cwi(atr_data_t *data)
{
	uint8_t i;

	if (data->atr_nti <= 2) {
		return (ATR_T1_CWI_DEFAULT);
	}

	for (i = 2; i < data->atr_nti; i++) {
		if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
			if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TB) !=
			    0) {
				uint8_t tb = data->atr_ti[i].atrti_tb;
				return (ATR_T1_TB0_CWI(tb));
			}

			return (ATR_T1_CWI_DEFAULT);
		}
	}

	return (ATR_T1_CWI_DEFAULT);
}

atr_clock_stop_t
atr_clock_stop(atr_data_t *data)
{
	uint8_t i;

	for (i = 0; i < data->atr_nti; i++) {
		if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T15) {
			if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TA) !=
			    0) {
				uint8_t ta = data->atr_ti[i].atrti_ta;
				return (ATR_T15_TA0_CLOCK(ta));
			}

			return (ATR_CLOCK_STOP_NONE);
		}
	}

	return (ATR_CLOCK_STOP_NONE);
}

atr_t1_checksum_t
atr_t1_checksum(atr_data_t *data)
{
	uint8_t i;

	if (data->atr_nti <= 2) {
		return (ATR_T1_CHECKSUM_DEFAULT);
	}

	for (i = 2; i < data->atr_nti; i++) {
		if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
			if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TC) !=
			    0) {
				if (ATR_T1_TC0_CRC(data->atr_ti[i].atrti_tc)) {
					return (ATR_T1_CHECKSUM_CRC);
				} else {
					return (ATR_T1_CHECKSUM_LRC);
				}
			}

			return (ATR_T1_CHECKSUM_DEFAULT);
		}
	}

	return (ATR_T1_CHECKSUM_DEFAULT);

}

uint8_t
atr_t1_bwi(atr_data_t *data)
{
	uint8_t i;

	if (data->atr_nti <= 2) {
		return (ATR_T1_BWI_DEFAULT);
	}

	for (i = 2; i < data->atr_nti; i++) {
		if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
			if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TB) !=
			    0) {
				uint8_t tb = data->atr_ti[i].atrti_tb;
				return (ATR_T1_TB0_BWI(tb));
			}

			return (ATR_T1_BWI_DEFAULT);
		}
	}

	return (ATR_T1_BWI_DEFAULT);
}

uint8_t
atr_t1_ifsc(atr_data_t *data)
{
	uint8_t i;

	if (data->atr_nti <= 2) {
		return (ATR_T1_IFSC_DEFAULT);
	}

	for (i = 2; i < data->atr_nti; i++) {
		if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
			if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TA) !=
			    0) {
				return (data->atr_ti[i].atrti_ta);
			}

			return (ATR_T1_IFSC_DEFAULT);
		}
	}

	return (ATR_T1_IFSC_DEFAULT);
}

/*
 * Attempt to determine which set of data rates we should be able to use for a
 * given class of protocol. Here we want to do the calculation based on the CCID
 * specification, section 9.4.x. To use these higher rates we need:
 *
 * + Reader's data rate > frequency * Di / Fi.
 *
 * To determine which rate and frequency we use, we look at the reader's
 * features. If the reader supports both the Automatic baud rate and automatic
 * ICC clock frequency change, then we use the _maximum_ rate. Otherwise we will
 * indicate that we can use the ATR's properties, but will require changing the
 * default data rate.
 *
 * Now, some ICC devices are not negotiable. In those cases, we'll see if we can
 * fit it in with either the default or maximum data rates. If not, then we'll
 * not be able to support this card.
 *
 * There are two wrinkles that exist in this. The first is supported frequencies
 * and data rates. If there are no additional data rates supported, then all of
 * the data rates between the default and max are supported. If not, then only
 * those specified in the data rates array are supported.
 *
 * The second hurdle is that we need to do this division and try and avoid the
 * pitfalls of floating point arithmetic, as floating point is not allowed in
 * the kernel (and this is shared). Importantly that means only integers are
 * allowed here.
 */
atr_data_rate_choice_t
atr_data_rate(atr_data_t *data, ccid_class_descr_t *class, uint32_t *rates,
    uint_t nrates, uint32_t *dataratep)
{
	uint_t nfeats = CCID_CLASS_F_AUTO_ICC_CLOCK | CCID_CLASS_F_AUTO_BAUD;
	uint8_t di, fi;
	uint_t dival, fival;
	boolean_t autospeed, negotiable, exprates;
	uint64_t maxval, defval;

	if ((data->atr_flags & ATR_F_VALID) == 0)
		return (ATR_RATE_UNSUPPORTED);

	di = atr_di_index(data);
	fi = atr_fi_index(data);
	dival = atr_di_index_to_value(di);
	fival = atr_fi_index_to_value(fi);
	autospeed = (class->ccd_dwFeatures & nfeats) == nfeats;
	exprates = class->ccd_bNumDataRatesSupported != 0;
	negotiable = atr_params_negotiable(data);

	/*
	 * We don't support cards with fixed rates at this time as it's not
	 * clear what that rate should be. If it's negotiable, we'll let them
	 * run at the default. Otherwise, we have to fail the request until
	 * we implement the logic to search their data rates.
	 */
	if (exprates) {
		if (negotiable) {
			return (ATR_RATE_USEDEFAULT);
		}
		return (ATR_RATE_UNSUPPORTED);
	}

	/*
	 * This indicates that the card gave us values that were reserved for
	 * future use. If we could negotiate it, then just stick with the
	 * default paramters. Otherwise, return that we can't support this ICC.
	 */
	if (dival == 0 || fival == 0) {
		if (negotiable)
			return (ATR_RATE_USEDEFAULT);
		return (ATR_RATE_UNSUPPORTED);
	}

	/*
	 * Calculate the maximum and default values.
	 */
	maxval = class->ccd_dwMaximumClock * 1000;
	maxval *= dival;
	maxval /= fival;

	defval = class->ccd_dwDefaultClock * 1000;
	defval *= dival;
	defval /= fival;

	/*
	 * We're allowed any set of data rates between the default and the
	 * maximum. Check if the maximum data rate will work for either the
	 * default or maximum clock. If so, then we can use the cards rates.
	 *
	 * To account for the fact that we may have had a fractional value,
	 * we require a strict greater than comparison.
	 */
	if ((uint64_t)class->ccd_dwMaxDataRate > maxval ||
	    (uint64_t)class->ccd_dwMaxDataRate > defval) {
		if (autospeed) {
			return (ATR_RATE_USEATR);
		}
	}

	/*
	 * If the CCID reader can't handle the ICC's proposed rates, then fall
	 * back to the defaults if we're allowed to negotiate. Otherwise, we're
	 * not able to use this ICC.
	 */
	if (negotiable) {
		return (ATR_RATE_USEDEFAULT);
	}

	return (ATR_RATE_UNSUPPORTED);
}

void
atr_data_reset(atr_data_t *data)
{
	bzero(data, sizeof (*data));
}

#ifdef	_KERNEL
atr_data_t *
atr_data_alloc(void)
{
	return (kmem_zalloc(sizeof (atr_data_t), KM_SLEEP));
}

void
atr_data_free(atr_data_t *data)
{
	kmem_free(data, sizeof (atr_data_t));
}

/*
 * Make sure that the response we got from the ICC is valid. It must pass
 * checksum and have the PPSS value set correctly. The protocol must match
 * what we requested; however, the PPS1-3 bits are a bit different. They may
 * only be set in the response if we set them in the request. However, they
 * do not have to be set in the response.
 */
boolean_t
atr_pps_valid(void *reqbuf, size_t reqlen, void *respbuf, size_t resplen)
{
	uint8_t val, i, reqidx, respidx;
	uint8_t *req = reqbuf, *resp = respbuf;

	if (resplen > PPS_LEN_MAX || resplen < PPS_LEN_MIN)
		return (B_FALSE);

	/*
	 * Before we validate the data, make sure the checksum is valid.
	 */
	for (i = 0, val = 0; i < resplen; i++) {
		val ^= resp[i];
	}

	/* Checksum failure */
	if (val != 0) {
		return (B_FALSE);
	}

	/*
	 * We should always have PPSS echoed back as we set it.
	 */
	if (resp[PPS_PPSS_INDEX] != PPS_PPSS_VAL) {
		return (B_FALSE);
	}

	/*
	 * Go through and make sure the number of bytes present makes sense for
	 * the number of bits set in PPS1.
	 */
	val = PPS_LEN_MIN;
	if (resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS1)
		val++;
	if (resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS2)
		val++;
	if (resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS3)
		val++;
	if (val != resplen)
		return (B_FALSE);

	/*
	 * Now we've finally verified that the response is syntactically valid.
	 * We must go through and make sure that it is semantically valid.
	 */
	if (PPS_PPS0_PROT(req[PPS_PPS0_INDEX]) !=
	    PPS_PPS0_PROT(resp[PPS_PPS0_INDEX])) {
		return (B_FALSE);
	}

	/*
	 * When checking the PPS bit and extensions, we first check in the
	 * response as a bit in the request is allowed to not be in the
	 * response. But not the opposite way around. We also have to keep track
	 * of the fact that the index for values will vary.
	 */
	reqidx = respidx = PPS_PPS0_INDEX + 1;
	if ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) != 0) {
		if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) == 0) {
			return (B_FALSE);
		}

		if (req[reqidx] != resp[respidx]) {
			return (B_FALSE);
		}

		reqidx++;
		respidx++;
	} else if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) != 0) {
		reqidx++;
	}

	if ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS2) != 0) {
		if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS2) == 0) {
			return (B_FALSE);
		}

		if (req[reqidx] != resp[respidx]) {
			return (B_FALSE);
		}

		reqidx++;
		respidx++;
	} else if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS2) != 0) {
		reqidx++;
	}

	if ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS3) != 0) {
		/*
		 * At this time, we never specify PPS3 in a request. Therefore
		 * if it is present in the response, treat this as an invalid
		 * request.
		 */
		return (B_FALSE);
	}

	return (B_TRUE);
}

uint_t
atr_pps_generate(uint8_t *buf, size_t buflen, atr_protocol_t prot,
    boolean_t pps1, uint8_t fi, uint8_t di, boolean_t pps2, uint8_t spu)
{
	uint8_t protval, cksum, i;
	uint_t len = 0;

	if (buflen < PPS_BUFFER_MAX)
		return (0);

	buf[PPS_PPSS_INDEX] = PPS_PPSS_VAL;
	switch (prot) {
	case ATR_P_T0:
		protval = 0;
		break;
	case ATR_P_T1:
		protval = 1;
		break;
	default:
		return (0);
	}

	buf[PPS_PPS0_INDEX] = PPS_PPS0_PROT(protval);
	len = 2;
	if (pps1) {
		buf[PPS_PPS0_INDEX] |= PPS_PPS0_PPS1;
		buf[len++] = PPS_PPS1_SETVAL(fi, di);
	}

	if (pps2) {
		buf[PPS_PPS0_INDEX] |= PPS_PPS0_PPS2;
		buf[len++] = spu;
	}

	/*
	 * The checksum must xor to zero.
	 */
	for (i = 0, cksum = 0; i < len; i++) {
		cksum ^= buf[i];
	}
	buf[len++] = cksum;
	return (len);
}

/*
 * The caller of this wants to know if the Fi/Di values that they proposed were
 * accepted. The caller must have already called atr_pps_valid(). At this point,
 * we can say that the value was accepted if the PPS1 bit is set.
 */
boolean_t
atr_pps_fidi_accepted(void *respbuf, size_t len)
{
	uint8_t *resp = respbuf;
	return ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) != 0);
}

#else	/* !_KERNEL */
atr_data_t *
atr_data_alloc(void)
{
	return (calloc(1, sizeof (atr_data_t)));
}

void
atr_data_free(atr_data_t *data)
{
	if (data == NULL)
		return;
	free(data);
}

/*
 * This table maps the bit values for Fi from 7816-3:2006 section 8.3 Table 9.
 * The table is up to 6 bits wide. Entries not present are RFU. We use NULL as a
 * sentinel to indicate that.
 */
static const char *atr_voltage_table[64] = {
	NULL,			/* 00 0000 */
	"5V",			/* 00 0001 */
	"3V",			/* 00 0010 */
	"5V, 3V",		/* 00 0011 */
	"1.5V",			/* 00 0100 */
	NULL,			/* 00 0101 */
	"3V, 1.5V",		/* 00 0110 */
	"5V, 3V, 1.5V"		/* 00 0111 */
};

static void
atr_data_dump_ta(atr_ti_t *atp, FILE *out, uint_t level)
{
	uint8_t ta;

	if (!(atp->atrti_flags & ATR_TI_HAVE_TA)) {
		return;
	}

	ta = atp->atrti_ta;
	(void) fprintf(out, "   %c%c%c+-> TA%u 0x%02x",
	    atp->atrti_flags & ATR_TI_HAVE_TD ? '|' : ' ',
	    atp->atrti_flags & ATR_TI_HAVE_TC ? '|' : ' ',
	    atp->atrti_flags & ATR_TI_HAVE_TB ? '|' : ' ',
	    atp->atrti_ti_val, ta);
	switch (atp->atrti_ti_val) {
	case 1:
		(void) fprintf(out, "; Fi: %s, F(max): %s MHz, Di: %s",
		    atr_fi_table[ATR_TA1_FTABLE(ta)],
		    atr_fmax_table[ATR_TA1_FTABLE(ta)],
		    atr_di_table[ATR_TA1_DITABLE(ta)]);
		break;
	case 2:
		(void) fprintf(out, "; ICC in %s mode; %shonoring TA1; default "
		    "T=%u",
		    ATR_TA2_CANCHANGE(ta) ? "negotiable" : "specific",
		    ATR_TA2_HONORTA1(ta) ? "" : "not ",
		    ATR_TA2_PROTOCOL(ta));
		break;
	default:
		switch (atp->atrti_protocol) {
		case ATR_PROTOCOL_T1:
			if (level != 0)
				break;
			if (ta == 0 || ta == 0xff) {
				(void) fprintf(out, "; IFSC: RFU");
			} else {
				(void) fprintf(out, "; IFSC: %u", ta);
			}
			break;
		case ATR_PROTOCOL_T15:
			if (level != 0)
				break;
			(void) fprintf(out, "; Clock stop: %s, Supported "
			    "Voltage: %s",
			    atr_clock_table[ATR_T15_TA0_CLOCK(ta)],
			    atr_voltage_table[ATR_T15_TA0_VOLTAGE(ta)] != NULL ?
			    atr_voltage_table[ATR_T15_TA0_VOLTAGE(ta)] : "RFU");
			break;
		default:
			break;
		}
	}
	(void) fprintf(out, "\n");
}

static void
atr_data_dump_tb(atr_ti_t *atp, FILE *out, uint_t level)
{
	uint8_t tb;

	if (!(atp->atrti_flags & ATR_TI_HAVE_TB)) {
		return;
	}

	tb = atp->atrti_tb;
	(void) fprintf(out, "   %c%c+--> TB%u 0x%02x",
	    atp->atrti_flags & ATR_TI_HAVE_TD ? '|' : ' ',
	    atp->atrti_flags & ATR_TI_HAVE_TC ? '|' : ' ',
	    atp->atrti_ti_val, tb);
	switch (atp->atrti_ti_val) {
	case 1:
	case 2:
		(void) fprintf(out, "; deprecated");
		break;
	default:
		switch (atp->atrti_protocol) {
		case ATR_PROTOCOL_T1:
			if (level != 0)
				break;
			(void) fprintf(out, "; CWI: %u, BWI: %u\n",
			    ATR_T1_TB0_CWI(tb),
			    ATR_T1_TB0_BWI(tb));
			break;
		case ATR_PROTOCOL_T15:
			if (level != 0)
				break;
			(void) fprintf(out, "; SPU: %s", tb == 0 ? "not used" :
			    ATR_T15_TB0_SPU_STANDARD(tb) ? "standard" :
			    "proprietary");
			break;
		default:
			break;
		}
	}
	(void) fprintf(out, "\n");
}

static void
atr_data_dump_tc(atr_ti_t *atp, FILE *out, uint_t level)
{
	uint8_t tc;

	if (!(atp->atrti_flags & ATR_TI_HAVE_TC)) {
		return;
	}

	tc = atp->atrti_tc;
	(void) fprintf(out, "   %c+---> TC%u 0x%02x",
	    atp->atrti_flags & ATR_TI_HAVE_TD ? '|' : ' ',
	    atp->atrti_ti_val, tc);

	switch (atp->atrti_ti_val) {
	case 1:
		(void) fprintf(out, "; Extra Guard Time Integer: %u", tc);
		break;
	case 2:
		if (atp->atrti_protocol != ATR_PROTOCOL_T0) {
			(void) fprintf(out, "; illegal value -- only valid for "
			    "T=0");
		} else {
			(void) fprintf(out, "; Waiting Time Integer: %u", tc);
		}
		break;
	default:
		switch (atp->atrti_protocol) {
		case ATR_PROTOCOL_T1:
			if (level != 0)
				break;
			(void) fprintf(out, "; Error Detection Code: %s",
			    ATR_T1_TC0_CRC(tc) ? "CRC" : "LRC");
			break;
		default:
			break;
		}
	}
	(void) fprintf(out, "\n");
}

void
atr_data_hexdump(const uint8_t *buf, size_t nbytes, FILE *out)
{
	size_t i, j;

	/* Print out the header */
	(void) fprintf(out, "%*s    0", 4, "");
	for (i = 1; i < 16; i++) {
		if (i % 4 == 0 && i % 16 != 0) {
			(void) fprintf(out, " ");
		}

		(void) fprintf(out, "%2x", i);
	}
	(void) fprintf(out, "  0123456789abcdef\n");

	/* Print out data */
	for (i = 0; i < nbytes; i++) {

		if (i % 16 == 0) {
			(void) fprintf(out, "%04x:  ", i);
		}

		if (i % 4 == 0 && i % 16 != 0) {
			(void) fprintf(out, " ");
		}

		(void) fprintf(out, "%02x", buf[i]);

		if (i % 16 == 15 || i + 1 == nbytes) {
			for (j = (i % 16) + 1; j < 16; j++) {
				if (j % 4 == 0 && j % 16 != 0) {
					(void) fprintf(out, " ");
				}

				(void) fprintf(out, "  ");
			}

			(void) fprintf(out, "  ");
			for (j = i - (i % 16); j <= i; j++) {
				(void) fprintf(out, "%c",
				    isprint(buf[j]) ? buf[j] : '.');
			}
			(void) printf("\n");
		}
	}
}

static void
atr_data_hexdump_historical(atr_data_t *data, FILE *out)
{
	(void) fprintf(out, "Dumping raw historical bytes\n");

	atr_data_hexdump(data->atr_historic, data->atr_nhistoric, out);
}

static void
atr_data_dump_historical(atr_data_t *data, FILE *out)
{
	uint8_t cat;

	(void) fprintf(out, "Historic Data: %u bytes", data->atr_nhistoric);
	if (data->atr_nhistoric == 0) {
		(void) fprintf(out, "\n");
		return;
	}

	cat = data->atr_historic[0];
	(void) fprintf(out, "; format (0x%02x) ", cat);
	if (cat == ATR_HIST_CAT_MAND_STATUS) {
		(void) fprintf(out, "card status, not shown");
	} else if (cat == ATR_HIST_CAT_TLV_STATUS) {
		(void) fprintf(out, "COMPACT-TLV, not shown");
	} else if (cat >= ATR_HIST_CAT_RFU_MIN && cat <= ATR_HIST_CAT_RFU_MAX) {
		(void) fprintf(out, "reserved\n");
		atr_data_hexdump_historical(data, out);
		return;
	} else {
		(void) fprintf(out, "proprietary\n");
		atr_data_hexdump_historical(data, out);
		return;
	}
}

void
atr_data_dump(atr_data_t *data, FILE *out)
{
	uint8_t i, level;
	if ((data->atr_flags & ATR_F_VALID) == 0)
		return;

	(void) fprintf(out, "TS  0x%02u - ", data->atr_raw[0]);
	if (data->atr_flags & ATR_F_USES_DIRECT) {
		(void) fprintf(out, "direct convention\n");
	} else {
		(void) fprintf(out, "inverse convention\n");
	}

	level = 0;
	for (i = 0; i < data->atr_nti; i++) {
		atr_ti_t *atp = &data->atr_ti[i];

		/*
		 * Various protocols may appear multiple times, indicating
		 * different sets of bits each time. When dealing with T0 and
		 * TD1, the protocol doesn't matter. Otherwise if we have the
		 * same value, we should increment this.
		 */
		if (i <= 2) {
			level = 0;
		} else if (atp->atrti_protocol ==
		    data->atr_ti[i - 1].atrti_protocol) {
			level++;
		} else {
			level = 0;
		}

		if (i == 0) {
			(void) fprintf(out, "T0  ");
		} else {
			(void) fprintf(out, "TD%u ", i);
		}
		(void) fprintf(out, "0x%02x\n",
		    data->atr_raw[atp->atrti_td_idx]);
		(void) fprintf(out, "      |+-> ");
		if (i == 0) {
			(void) fprintf(out, "%u historical bytes\n",
			    data->atr_nhistoric);
		} else {
			(void) fprintf(out, "protocol T=%u\n",
			    atp->atrti_protocol);
		}
		(void) fprintf(out, "      v\n");
		(void) fprintf(out, " 0r%u%u%u%u\n",
		    atp->atrti_flags & ATR_TI_HAVE_TD ? 1 : 0,
		    atp->atrti_flags & ATR_TI_HAVE_TC ? 1 : 0,
		    atp->atrti_flags & ATR_TI_HAVE_TB ? 1 : 0,
		    atp->atrti_flags & ATR_TI_HAVE_TA ? 1 : 0);

		atr_data_dump_ta(atp, out, level);
		atr_data_dump_tb(atp, out, level);
		atr_data_dump_tc(atp, out, level);
		if (atp->atrti_flags & ATR_TI_HAVE_TD) {
			(void) fprintf(out, "   v\n");
		}
	}

	atr_data_dump_historical(data, out);

	if (data->atr_flags & ATR_F_HAS_CHECKSUM) {
		(void) fprintf(out, "TCK  0x%02x\n", data->atr_cksum);
	} else {
		(void) fprintf(out, "TCK  ----; Checksum not present\n");
	}

}
#endif	/* _KERNEL */