add ISO7816 peripherals
configure SERCOM 0 to 6 peripherals to communicate using the
ISO7816 T=0 protocol.
SERCOM7 should be for the 8th SIM card, but for now it is used as
UART debug output.
Auto-detection between SERCOM for the 8th SIM and debug UART will
be done later.
Change-Id: I3f1411ec5bc2ed7dfa714550d041f52be665132a
diff --git a/sysmoOCTSIM/examples/driver_examples.c b/sysmoOCTSIM/examples/driver_examples.c
index 8384c87..14f1ae5 100644
--- a/sysmoOCTSIM/examples/driver_examples.c
+++ b/sysmoOCTSIM/examples/driver_examples.c
@@ -11,6 +11,209 @@
#include "utils.h"
/**
+ * Example of using SIM0 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM0[12] = "Hello World!";
+
+static void tx_cb_SIM0(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM0_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM0, USART_ASYNC_TXC_CB, tx_cb_SIM0);
+ /*usart_async_register_callback(&SIM0, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM0, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM0, &io);
+ usart_async_enable(&SIM0);
+
+ io_write(io, example_SIM0, 12);
+}
+
+/**
+ * Example of using SIM1 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM1[12] = "Hello World!";
+
+static void tx_cb_SIM1(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM1_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM1, USART_ASYNC_TXC_CB, tx_cb_SIM1);
+ /*usart_async_register_callback(&SIM1, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM1, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM1, &io);
+ usart_async_enable(&SIM1);
+
+ io_write(io, example_SIM1, 12);
+}
+
+/**
+ * Example of using SIM2 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM2[12] = "Hello World!";
+
+static void tx_cb_SIM2(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM2_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM2, USART_ASYNC_TXC_CB, tx_cb_SIM2);
+ /*usart_async_register_callback(&SIM2, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM2, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM2, &io);
+ usart_async_enable(&SIM2);
+
+ io_write(io, example_SIM2, 12);
+}
+
+/**
+ * Example of using SIM3 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM3[12] = "Hello World!";
+
+static void tx_cb_SIM3(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM3_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM3, USART_ASYNC_TXC_CB, tx_cb_SIM3);
+ /*usart_async_register_callback(&SIM3, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM3, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM3, &io);
+ usart_async_enable(&SIM3);
+
+ io_write(io, example_SIM3, 12);
+}
+
+/**
+ * Example of using SIM4 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM4[12] = "Hello World!";
+
+static void tx_cb_SIM4(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM4_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM4, USART_ASYNC_TXC_CB, tx_cb_SIM4);
+ /*usart_async_register_callback(&SIM4, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM4, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM4, &io);
+ usart_async_enable(&SIM4);
+
+ io_write(io, example_SIM4, 12);
+}
+
+/**
+ * Example of using SIM5 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM5[12] = "Hello World!";
+
+static void tx_cb_SIM5(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM5_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM5, USART_ASYNC_TXC_CB, tx_cb_SIM5);
+ /*usart_async_register_callback(&SIM5, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM5, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM5, &io);
+ usart_async_enable(&SIM5);
+
+ io_write(io, example_SIM5, 12);
+}
+
+/**
+ * Example of using SIM6 to write "Hello World" using the IO abstraction.
+ *
+ * Since the driver is asynchronous we need to use statically allocated memory for string
+ * because driver initiates transfer and then returns before the transmission is completed.
+ *
+ * Once transfer has been completed the tx_cb function will be called.
+ */
+
+static uint8_t example_SIM6[12] = "Hello World!";
+
+static void tx_cb_SIM6(const struct usart_async_descriptor *const io_descr)
+{
+ /* Transfer completed */
+}
+
+void SIM6_example(void)
+{
+ struct io_descriptor *io;
+
+ usart_async_register_callback(&SIM6, USART_ASYNC_TXC_CB, tx_cb_SIM6);
+ /*usart_async_register_callback(&SIM6, USART_ASYNC_RXC_CB, rx_cb);
+ usart_async_register_callback(&SIM6, USART_ASYNC_ERROR_CB, err_cb);*/
+ usart_async_get_io_descriptor(&SIM6, &io);
+ usart_async_enable(&SIM6);
+
+ io_write(io, example_SIM6, 12);
+}
+
+/**
* Example of using UART_debug to write "Hello World" using the IO abstraction.
*
* Since the driver is asynchronous we need to use statically allocated memory for string