apps/xplain-bc/main.c

Go to the documentation of this file.

#include <led.h>
#include <gpio.h>
#include <board.h>
#include <debug.h>
#include <dmapool.h>
#include <mainloop.h>
#include <clk/sys.h>
#include <usb/dev_mux.h>
#include <usb/request.h>
#include <usb/udc.h>

#include "xplain-bc.h"

static struct app_usb_mode_task *app_usb_mode_task_of_task(
                struct workqueue_task *task)
{
        return container_of(task, struct app_usb_mode_task, task);
}

static void app_usb_mode_worker(struct workqueue_task *task)
{
        struct app_usb_mode_task        *usb_mode_task;
        bool                            is_usb_msc_mode;

        usb_mode_task = app_usb_mode_task_of_task(task);
        is_usb_msc_mode = board_gpio_is_usb_msc_mode();

        /* Check if MSC is enabled and mode pin is high (i.e. disable it). */
        if (usb_mode_task->msc_enabled && !is_usb_msc_mode) {
                /*
                 * If SPI is busy, wait for it to complete. \todo Correct usage
                 * master.base.status check for OPERATION_IN_PROGRESS?
                 */
                if (usb_mode_task->master.base.status == OPERATION_IN_PROGRESS)
                        goto out_retry;

                /* Detach to the USB bus, disabling the MSC interface. */
                udc_detach(usb_mode_task->udc);
                usb_mode_task->msc_enabled = false;

                /* Set the SPI in slave mode. */
                board_gpio_set_spi_master_mode(false);

                /* Release the XMEGA chip from reset, SPI bus is now ready. */
                board_gpio_mcu_reset(false);
                led_deactivate(BOARD_LED_RED);
        }
        /* Check if MSC is disabled and mode pin is low (i.e. enable it). */
        else if (!usb_mode_task->msc_enabled && is_usb_msc_mode) {
                /* The XMEGA interferes on the SPI bus, keep it in reset. */
                board_gpio_mcu_reset(true);

                /* Set the SPI in master mode. */
                board_gpio_set_spi_master_mode(true);

                /* Attach to the USB bus, disabling the MSC interface. */
                udc_attach(usb_mode_task->udc);
                usb_mode_task->msc_enabled = true;
                led_activate(BOARD_LED_RED);
        }

out_retry:
        workqueue_add_task(&main_workqueue, &usb_mode_task->task);
}

static void app_dataflash_ready(struct workqueue_task *task)
{
        struct app_usb_mode_task        *usb_mode_task;
        usb_mode_task = app_usb_mode_task_of_task(task);
        board_gpio_set_spi_master_mode(false);
        board_gpio_mcu_reset(false);
        workqueue_task_set_work_func(&usb_mode_task->task, app_usb_mode_worker);
        workqueue_add_task(&main_workqueue, &usb_mode_task->task);
}

int main(void)
{
        static struct app_usb_mode_task  usb_mode_task;
        struct udc                       *udc;

        cpu_irq_enable();
        sysclk_init();
        dbg_init();
        board_init();
        workqueue_init(&main_workqueue);
        dma_pool_init();
        buffer_pool_init();
        usb_init();

        dbg_info("USB Mass Storage device initializing...\n");

        udc = udc_init();
        if (!udc) {
                dbg_panic("UDC initialization failed\n");
                return 1;
        }

        usb_mode_task.udc = udc;
        usb_mode_task.msc_enabled = false;

        workqueue_task_init(&(usb_mode_task.task), app_usb_mode_worker);

        /* Check USB mode pin to see if USB should be attached or detached at
         * startup. If MSC interface should not be enabled set workqueue to
         * app_dataflash_ready, which will set the SPI interface in slave mode
         * and release the XMEGA reset line.
         */
        if (!board_gpio_is_usb_msc_mode()) {
                workqueue_task_set_work_func(&usb_mode_task.task,
                                app_dataflash_ready);
        }

        dataflash_init(&usb_mode_task);
        mainloop_run(&main_workqueue);
}

---