drivers/usb/at90usb/at90usb_core.c

Go to the documentation of this file.

#include <assert.h>
#include <debug.h>
#include <intc.h>
#include <physmem.h>
#include <stdbool.h>
#include <interrupt.h>

#include <clk/sys.h>

#include <chip/clk.h>
#include <chip/regs.h>
#include <chip/at90usb.h>
#include <chip/irq-map.h>

#include <cpu/io.h>

#include <usb/udc.h>

#include <app/usb.h>

#include "at90usb_internal.h"
#include "at90usb_regs.h"

/* Configuration sanity-checks. */
#if defined(CONFIG_UDC) && !defined(CHIP_AT90USB_HAS_DEVICE)
# error AT90USB: This chip does not have a Device Controller
#endif
#if defined(CONFIG_AT90USB_OTG) && !defined(CHIP_AT90USB_HAS_OTG)
# error AT90USB: This chip does not support USB On-The-Go
#endif

static inline
struct at90usb_udc *at90usb_get_udc(struct at90usb_controller *at90usb)
{
#ifdef CONFIG_UDC
        return at90usb->udc;
#else
        return NULL;
#endif
}

static inline
struct at90usb_host *at90usb_get_host(struct at90usb_controller *at90usb)
{
        return NULL;
}

static inline bool at90usb_is_otg(struct at90usb_controller *at90usb)
{
#ifdef CONFIG_AT90USB_OTG
        return true;
#else
        return false;
#endif
}

static void at90usb_check_vbus(struct at90usb_controller *at90usb)
{
        struct at90usb_udc *udc = at90usb_get_udc(at90usb);

        if (avr_read_reg8(USBSTA) & AT90USB_USBSTA_VBUS)
                at90usb_udc_vbus_on(udc);
        else
                at90usb_udc_vbus_off(udc);
}

static void at90usb_enter_device_mode(struct at90usb_controller *at90usb)
{
        struct at90usb_host     *host = at90usb_get_host(at90usb);
        struct at90usb_udc      *udc = at90usb_get_udc(at90usb);

        dbg_verbose("AT90USB: Entering device mode...\n");

        if (at90usb_host_is_enabled(host))
                at90usb_host_disable(host);
        if (!at90usb_udc_is_enabled(udc))
                at90usb_udc_enable(udc);

        avr_write_reg8(USBINT, avr_read_reg8(USBINT) & ~AT90USB_USBINT_VBUSTI);

        at90usb_check_vbus(at90usb);

        avr_write_reg8(USBCON, avr_read_reg8(USBCON) | AT90USB_USBCON_VBUSTE);

        dbg_verbose("AT90USB: USBCON=%02x\n", avr_read_reg8(USBCON));
}

static void at90usb_enter_host_mode(struct at90usb_controller *at90usb)
{
        struct at90usb_host     *host = at90usb_get_host(at90usb);
        struct at90usb_udc      *udc = at90usb_get_udc(at90usb);

        if (host) {
                if (at90usb_udc_is_enabled(udc))
                        at90usb_udc_disable(udc);
                if (!at90usb_host_is_enabled(host))
                        at90usb_host_enable(host);
        }
}

static void at90usb_check_id(struct at90usb_controller *at90usb)
{
        if (avr_read_reg8(USBSTA) & AT90USB_USBSTA_ID)
                at90usb_enter_device_mode(at90usb);
        else
                at90usb_enter_host_mode(at90usb);
}

static struct at90usb_controller the_at90usb_controller;

static void at90usb_generic_interrupt(void *data)
{
        struct at90usb_controller       *at90usb = data;
        struct at90usb_udc              *udc;
        struct at90usb_host             *hostb;
        uint8_t                         reg;

        reg = avr_read_reg8(USBINT);

        if (at90usb_is_otg(at90usb)) {
                if (reg & AT90USB_USBINT_IDTI) {
                        avr_write_reg8(USBINT, reg & ~AT90USB_USBINT_IDTI);
                        at90usb_check_id(at90usb);
                }

                /* TODO: More OTG stuff */
        }

        udc = at90usb_get_udc(at90usb);
        if (at90usb_udc_is_enabled(udc)) {
                if (reg & AT90USB_USBINT_VBUSTI) {
                        avr_write_reg8(USBINT, reg & ~AT90USB_USBINT_VBUSTI);
                        at90usb_check_vbus(at90usb);
                }

                if (avr_read_reg8(UDINT) & avr_read_reg8(UDIEN)) {
                        avr_write_reg8(UDIEN, avr_read_reg8(UDIEN)
                                        & ~avr_read_reg8(UDINT));
                        workqueue_add_task(&main_workqueue, &udc->task);
                }
        }

        hostb = at90usb_get_host(at90usb);
        if (at90usb_host_is_enabled(hostb)) {
                /* TODO: More HOST stuff */
        }
}
INTC_DEFINE_HANDLER(USB_GEN_IRQ, at90usb_generic_interrupt, 0);

static void at90usb_ep_interrupt(void *data)
{
        struct at90usb_controller       *at90usb = data;
        struct at90usb_udc              *udc;
        struct at90usb_host             *hostb;
        /* Shadow current active endpoint. */
        uint8_t                         uenum = avr_read_reg8(UENUM);

        if (at90usb_is_otg(at90usb)) {
                /* TODO: More OTG stuff? */
        }

        udc = at90usb_get_udc(at90usb);
        if (at90usb_udc_is_enabled(udc)) {
                usb_ep_id_t     ep_id;
                uint8_t         ueint = avr_read_reg8(UEINT);

                for (ep_id = 0; ep_id < APP_UDC_NR_ENDPOINTS; ep_id++) {
                        if (ueint & AT90USB_UEINT_EP(ep_id)) {
                                struct at90usb_udc_ep *ep = &udc->ep[ep_id];
                                avr_write_reg8(UENUM, ep_id);
                                ep->ueienx = avr_read_reg8(UEIENX);
                                avr_write_reg8(UEIENX, ep->ueienx
                                                & ~avr_read_reg8(UEINTX));
                                workqueue_add_task(&main_workqueue,
                                                &ep->task);
                        }
                }
        }

        hostb = at90usb_get_host(at90usb);
        if (at90usb_host_is_enabled(hostb)) {
                /* TODO: More HOST stuff? */
        }

        /* Restore the endpoint to what it was before the interrupt. */
        avr_write_reg8(UENUM, uenum);
}
INTC_DEFINE_HANDLER(USB_EP_IRQ, at90usb_ep_interrupt, 0);

static struct at90usb_controller *at90usb_init(void)
{
        struct at90usb_controller       *at90usb = &the_at90usb_controller;
        uint8_t                         usbcon;

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

        sysclk_enable_module(SYSCLK_USB);
        intc_setup_handler(USB_GEN_IRQ, 0, at90usb);
        intc_setup_handler(USB_EP_IRQ, 0, at90usb);

#ifdef CONFIG_UDC
        at90usb->udc = at90usb_udc_init();
        if (!at90usb->udc)
                goto err_udc;
#endif
#ifdef CONFIG_AT90USB_HOST
        at90usb->host = at90usb_host_init();
        if (!at90usb->host)
                goto err_host;
#endif

        clk_enable_at90usb();

        /* Keep the FRZCLK bit if set in USBCON. This bit must be held active
         * while the USB peripheral is enabled. And then cleared on a following
         * write to USBCON to enable the USB peripheral. */
        usbcon = (avr_read_reg8(USBCON) & AT90USB_USBCON_FRZCLK)
                | AT90USB_USBCON_USBE
                | AT90USB_USBCON_OTGPADE;

        if (at90usb_is_otg(at90usb)) {
                /* Full OTG */
                usbcon |= AT90USB_USBCON_IDTE;

                avr_write_reg8(UHWCON, AT90USB_UHWCON_UIDE);
                avr_write_reg8(USBINT, avr_read_reg8(USBINT)
                                & ~AT90USB_USBINT_IDTI);
                avr_write_reg8(USBCON, usbcon);
                avr_write_reg8(USBCON, usbcon & ~AT90USB_USBCON_FRZCLK);

                at90usb_check_id(at90usb);

                /* TODO: initialize HNP, SRP handling, etc. */
        } else if (at90usb_get_udc(at90usb)) {
                /* Device only */
                avr_write_reg8(UHWCON, AT90USB_UHWCON_UIMOD);
                avr_write_reg8(USBCON, usbcon);
                avr_write_reg8(USBCON, usbcon & ~AT90USB_USBCON_FRZCLK);

                at90usb_enter_device_mode(at90usb);
        } else if (at90usb_get_host(at90usb)) {
                /* Host only */
                avr_write_reg8(UHWCON, AT90USB_UHWCON_UVREGE);
                avr_write_reg8(USBCON, usbcon);
                avr_write_reg8(USBCON, usbcon & ~AT90USB_USBCON_FRZCLK);

                at90usb_enter_host_mode(at90usb);
        }

        return at90usb;

#ifdef CONFIG_AT90USB_HOST
err_host:
        at90usb_udc_shutdown(at90usb_get_udc(at90usb));
#endif
#ifdef CONFIG_UDC
err_udc:
#endif
        return NULL;
}

struct udc *udc_init(void)
{
        struct at90usb_controller *at90usb;

        at90usb = at90usb_init();
        if (!at90usb)
                return NULL;

        return &at90usb_get_udc(at90usb)->udc;
}

---