drivers/usb/usbb_core.c

Go to the documentation of this file.

#include <assert.h>
#include <debug.h>
#include <irq_handler.h>
#include <physmem.h>
#include <stdbool.h>
#include <chip/clk.h>
#include <chip/memory-map.h>
#include <chip/irq-map.h>
#include <chip/portmux.h>
#include <chip/usbb.h>
#include <usb/udc.h>

#include <app/config_dmapool.h>
#include <app/config_usb.h>

#include "usbb_internal.h"
#include "usbb_regs.h"

/* Configuration sanity-checks */
#if defined(CONFIG_USBB_UDC) && !defined(CHIP_USBB_HAS_DEVICE)
# error USBB: This chip does not have a Device Controller
#endif
#if defined(CONFIG_USBB_HOST) && !defined(CHIP_USBB_HAS_HOST)
# error USBB: This chip does not have a Host Controller
#endif
#if defined(CONFIG_USBB_OTG) && !defined(CHIP_USBB_HAS_OTG)
# error USBB: This chip does not support USB On-The-Go
#endif

#ifndef usbb_desc_physmem_pool
# define usbb_desc_physmem_pool hsb_sram_pool
#endif

#define USBB_DMA_DESC_ALIGN     4

struct dma_pool         usbb_desc_pool;

static inline struct usbb_udc *usbb_get_udc(struct usbb_controller *usbb)
{
#ifdef CONFIG_USBB_UDC
        return usbb->udc;
#else
        return NULL;
#endif
}

static inline struct usbb_host *usbb_get_host(struct usbb_controller *usbb)
{
#ifdef CONFIG_USBB_HOST
        return usbb->host;
#else
        return NULL;
#endif
}

static inline bool usbb_is_otg(struct usbb_controller *usbb)
{
#ifdef CONFIG_USBB_OTG
        return true;
#else
        return false;
#endif
}

static void usbb_check_vbus(struct usbb_controller *usbb)
{
        struct usbb_udc *udcb = usbb_get_udc(usbb);

        if (usbb_read_reg(USBSTA) & USBB_USBSTA_VBUS)
                usbb_udc_vbus_on(udcb);
        else
                usbb_udc_vbus_off(udcb);
}

static void usbb_enter_device_mode(struct usbb_controller *usbb)
{
        struct usbb_host        *host = usbb_get_host(usbb);
        struct usbb_udc         *udc = usbb_get_udc(usbb);
        uint32_t                usbcon;

        dbg_printf("USBB: Entering device mode...\n");

        if (usbb_host_is_enabled(host))
                usbb_host_disable(host);
        if (!usbb_udc_is_enabled(udc))
                usbb_udc_enable(udc);

        usbb_write_reg(USBSTACLR, USBB_VBUSTI);
        usbb_check_vbus(usbb);

        usbcon = usbb_read_reg(USBCON);
        usbcon |= USBB_VBUSTI;
        usbb_write_reg(USBCON, usbcon);

        dbg_printf("USBB: USBCON=%08x\n", usbb_read_reg(USBCON));
}

static void usbb_enter_host_mode(struct usbb_controller *usbb)
{
        struct usbb_host        *host = usbb_get_host(usbb);
        struct usbb_udc         *udc = usbb_get_udc(usbb);

        if (host) {
                if (usbb_udc_is_enabled(udc))
                        usbb_udc_disable(udc);
                if (!usbb_host_is_enabled(host))
                        usbb_host_enable(host);
        }
}

static void usbb_check_id(struct usbb_controller *usbb)
{
        if (usbb_read_reg(USBSTA) & USBB_USBSTA_ID)
                usbb_enter_device_mode(usbb);
        else
                usbb_enter_host_mode(usbb);
}

static void usbb_interrupt(void *data)
{
        struct usbb_controller  *usbb = data;
        struct usbb_udc         *udcb;
        struct usbb_host        *hostb;
        uint32_t                usbsta;

        usbsta = usbb_read_reg(USBSTA);

        if (usbb_is_otg(usbb)) {
                if (usbsta & USBB_IDTI) {
                        usbb_write_reg(USBSTACLR, USBB_IDTI);
                        usbb_check_id(usbb);
                }

                /* TODO: More OTG stuff */
        }

        udcb = usbb_get_udc(usbb);
        if (usbb_udc_is_enabled(udcb)) {
                if (usbsta & USBB_VBUSTI) {
                        usbb_write_reg(USBSTACLR, USBB_VBUSTI);
                        usbb_check_vbus(usbb);
                }

                usbb_udc_interrupt(udcb);
        }

        hostb = usbb_get_host(usbb);
        if (usbb_host_is_enabled(hostb)) {
                /* TODO: Host */
        }
}
DEFINE_IRQ_HANDLER(usbb, usbb_interrupt, 0);

static void usbb_init_desc_pool(void)
{
        phys_addr_t     addr;
        phys_size_t     size;

        size =  round_up(sizeof(struct usbb_sw_dma_desc), USBB_DMA_DESC_ALIGN);
        size *= CONFIG_USBB_NR_DMA_DESCRIPTORS;

        addr = physmem_alloc(&usbb_desc_physmem_pool, size,
                        USBB_DMA_DESC_ALIGN);
        assert(addr != PHYSMEM_ALLOC_ERR);

        dma_pool_init_coherent(&usbb_desc_pool, addr, size,
                        sizeof(struct usbb_sw_dma_desc), USBB_DMA_DESC_ALIGN);
}

static struct usbb_controller   the_usbb_controller;

static struct usbb_controller *usbb_init(void)
{
        struct usbb_controller  *usbb = &the_usbb_controller;
        uint32_t                usbcon;

        /*
         * Only do the initialization once. We might get called from
         * udc_init() as well as other initialization functions.
         */
        if (usbb_get_host(usbb) || usbb_get_udc(usbb))
                return usbb;

        usbb_init_desc_pool();

        usbcon = USBB_USBCON_USBE | USBB_USBCON_OTGPADE;

        if (clk_enable_usbb())
                return NULL;

        setup_irq_handler(USBB_IRQ, usbb, 0, usbb);

#ifdef CONFIG_USBB_UDC
        usbb->udc = usbb_udc_init();
        if (!usbb->udc)
                goto err_udc;
#endif
#ifdef CONFIG_USBB_HOST
        usbb->host = usbb_host_init();
        if (!usbb->host)
                goto err_host;
#endif

        if (usbb_is_otg(usbb)) {
                /* Full OTG */
                usbcon |= USBB_USBCON_UIDE;
                usbb_write_reg(USBCON, usbcon);
                usbb_write_reg(USBSTACLR, USBB_IDTI);
                usbb_check_id(usbb);
                usbcon |= USBB_IDTI;
                usbb_write_reg(USBCON, usbcon);

                /* TODO: initialize HNP, SRP handling, etc. */
        } else if (usbb_get_udc(usbb)) {
                /* Device only */
                usbcon |= USBB_USBCON_UIMOD_DEVICE;
                usbb_write_reg(USBCON, usbcon);
                usbb_enter_device_mode(usbb);
        } else if (usbb_get_host(usbb)) {
                /* Host only */
                usbcon |= USBB_USBCON_UIMOD_HOST;
                usbb_write_reg(USBCON, usbcon);
                usbb_enter_host_mode(usbb);
        }

        return usbb;

#ifdef CONFIG_USBB_HOST
        usbb_host_shutdown(usbb_get_host(usbb));
err_host:
#endif
#ifdef CONFIG_USBB_UDC
        usbb_udc_shutdown(usbb_get_udc(usbb));
err_udc:
#endif
        return NULL;
}

struct udc *udc_init(void)
{
        struct usbb_controller  *usbb;

        usbb = usbb_init();
        if (!usbb)
                return NULL;

        return &usbb_get_udc(usbb)->udc;
}

---