--- /dev/null
+# Makefile for usb host controllers
+
+.if ${MACHINE_ARCH} == "earm"
+
+.include <bsd.own.mk>
+
+SUBDIR= .WAIT base/earm
+
+.include <bsd.subdir.mk>
+
+.endif
--- /dev/null
+-------------------------------------------------------------------------------
+* INFORMATION: *
+-------------------------------------------------------------------------------
+README file for "USBD" USB host controller driver.
+
+created march-may 2014, JPEmbedded (info@jpembedded.eu)
+
+-------------------------------------------------------------------------------
+* KNOWN LIMITATIONS: *
+-------------------------------------------------------------------------------
+- Only first configuration can be selected for attached device
+- Only one device can be handled at a time, no hub functionality
+- DDEKit does not implement resource deallocation for corresponding thread
+ creation (see ddekit_thread_terminate, ddekit_thread_create) thus resources
+ are spilled
+- Driver assumes that there is no preemption for DDEKit threading
\ No newline at end of file
--- /dev/null
+#
+# Makefile for the EARM USBD
+#
+
+PROG= usbd
+SRCS= usbd.c usbd_earm.c hcd.c hcd_common.c hcd_ddekit.c musb_am335x.c musb_core.c
+
+.PATH: ${.CURDIR}/../ ${.CURDIR}/../../hcd ${.CURDIR}/../../hcd/musb
+
+CPPFLAGS+= -I${.CURDIR}/../../include
+
+DPADD+= ${LIBDDEKIT} ${LIBDDEKIT_USB_SERVER} ${LIBDEVMAN} ${LIBUSB} ${LIBMINC} ${LIBCLKCONF}
+LDADD+= -lddekit -lddekit_usb_server -ldevman -lusb -lminc -lclkconf
+
+MAN=
+
+BINDIR?= /usr/sbin
+
+.include <minix.service.mk>
\ No newline at end of file
--- /dev/null
+/*
+ * EARM USBD setup
+ */
+
+#include <minix/board.h>
+#include <minix/syslib.h>
+
+#include <usb/hcd_platforms.h>
+#include <usb/usb_common.h>
+#include <usb/usbd_interface.h>
+
+
+/*===========================================================================*
+ * usbd_init_hcd *
+ *===========================================================================*/
+int
+usbd_init_hcd(void)
+{
+ /* More specific platform type than just EARM */
+ static struct machine platform;
+
+ DEBUG_DUMP;
+
+ if (sys_getmachine(&platform)) {
+ USB_MSG("Getting machine type, failed");
+ return EXIT_FAILURE;
+ }
+
+ if (BOARD_IS_BB(platform.board_id)) {
+ USB_MSG("Using AM335x driver");
+ return musb_am335x_init();
+ } else {
+ USB_MSG("Only AM335x driver available");
+ return EXIT_FAILURE;
+ }
+}
+
+
+/*===========================================================================*
+ * usbd_deinit_hcd *
+ *===========================================================================*/
+void
+usbd_deinit_hcd(void)
+{
+ /* More specific platform type than just EARM */
+ static struct machine platform;
+
+ DEBUG_DUMP;
+
+ if (sys_getmachine(&platform)) {
+ USB_MSG("Getting machine type, failed");
+ return;
+ }
+
+ if (BOARD_IS_BB(platform.board_id))
+ musb_am335x_deinit();
+ else
+ USB_MSG("Only AM335x driver available");
+}
--- /dev/null
+/*
+ * Entry point for USBD service, that handles USB HCDs
+ */
+
+#include <ddekit/ddekit.h> /* ddekit_init */
+#include <ddekit/thread.h> /* DDEKit threading */
+
+#include <minix/devman.h> /* Initializing 'devman' */
+#include <minix/sef.h> /* SEF handling */
+
+#include <usb/usb_common.h>
+#include <usb/usbd_interface.h>
+
+
+/*===========================================================================*
+ * Local declarations *
+ *===========================================================================*/
+static int usbd_sef_handler(int, sef_init_info_t *);
+static int usbd_start(void);
+static void usbd_init(void);
+static void usbd_server_thread(void *);
+
+/* TODO: No headers for these... */
+extern void ddekit_minix_wait_exit(void); /* dde.c */
+extern void ddekit_usb_server_init(void); /* usb_server.c */
+
+
+/*===========================================================================*
+ * main *
+ *===========================================================================*/
+int
+main(int UNUSED(argc), char * UNUSED(argv[]))
+{
+ int ret_val;
+
+ USB_MSG("Starting USBD");
+
+ /* Basic SEF,DDE,... initialization */
+ usbd_init();
+
+ /* Assume failure unless usbd_start exits gracefully */
+ ret_val = EXIT_FAILURE;
+
+ /* USB host controllers initialization */
+ if (EXIT_SUCCESS == usbd_init_hcd()) {
+
+ /* Try initializing 'devman' */
+ if (EXIT_SUCCESS == devman_init()) {
+
+ /* Run USB driver (actually DDEKit threads)
+ * until this call returns: */
+ ret_val = usbd_start();
+
+ } else
+ USB_MSG("Initializing devman, failed");
+
+ /* Clean whatever was initialized */
+ usbd_deinit_hcd();
+
+ } else
+ USB_MSG("Initializing HCDs, failed");
+
+ return ret_val;
+}
+
+
+/*===========================================================================*
+ * usbd_sef_handler *
+ *===========================================================================*/
+static int
+usbd_sef_handler(int type, sef_init_info_t * UNUSED(info))
+{
+ DEBUG_DUMP;
+
+ switch (type) {
+ case SEF_INIT_FRESH:
+ USB_MSG("Initializing");
+ return EXIT_SUCCESS;
+
+ case SEF_INIT_LU:
+ USB_MSG("Updating, not implemented");
+ return EXIT_FAILURE;
+
+ case SEF_INIT_RESTART:
+ USB_MSG("Restarting, not implemented");
+ return EXIT_FAILURE;
+
+ default:
+ USB_MSG("illegal SEF type");
+ return EXIT_FAILURE;
+ }
+}
+
+
+/*===========================================================================*
+ * usbd_start *
+ *===========================================================================*/
+static int
+usbd_start(void)
+{
+ DEBUG_DUMP;
+
+ /* Driver's "main loop" is within DDEKit server thread */
+ if (NULL != ddekit_thread_create(usbd_server_thread, NULL, "USBD")) {
+ /* This will lock current thread until DDEKit terminates */
+ ddekit_minix_wait_exit();
+ return EXIT_SUCCESS;
+ } else
+ return EXIT_FAILURE;
+}
+
+
+/*===========================================================================*
+ * usbd_init *
+ *===========================================================================*/
+static void
+usbd_init(void)
+{
+ DEBUG_DUMP;
+
+ /* Set one handler for all messages */
+ sef_setcb_init_fresh(usbd_sef_handler);
+ sef_setcb_init_lu(usbd_sef_handler);
+ sef_setcb_init_restart(usbd_sef_handler);
+
+ /* Initialize DDEkit (involves sef_startup()) */
+ ddekit_init();
+}
+
+
+/*===========================================================================*
+ * usbd_server_thread *
+ *===========================================================================*/
+static void
+usbd_server_thread(void * UNUSED(unused))
+{
+ DEBUG_DUMP;
+
+ ddekit_usb_server_init();
+}
--- /dev/null
+/*
+ * Implementation of generic HCD
+ */
+
+#include <time.h> /* nanosleep */
+#include <string.h> /* memcpy */
+
+#include <usb/hcd_common.h>
+#include <usb/hcd_ddekit.h>
+#include <usb/hcd_interface.h>
+#include <usb/usb_common.h>
+
+
+/*===========================================================================*
+ * Local declarations *
+ *===========================================================================*/
+/* Thread to handle device logic */
+static void hcd_device_thread(void *);
+
+/* Procedure that locks device thread forever in case of error/completion */
+static void hcd_device_finish(hcd_device_state *, const char *);
+
+/* Typical USD device communication procedures */
+static int hcd_enumerate(hcd_device_state *);
+static int hcd_get_device_descriptor(hcd_device_state *);
+static int hcd_set_address(hcd_device_state *, int);
+static int hcd_get_descriptor_tree(hcd_device_state *);
+static int hcd_set_configuration(hcd_device_state *, int);
+static int hcd_handle_urb(hcd_device_state *);
+
+/* For internal use by more general methods */
+static int hcd_setup_packet(hcd_device_state *, hcd_ctrlrequest *);
+
+
+/*===========================================================================*
+ * Local definitions *
+ *===========================================================================*/
+/* TODO: Only one device at a time */
+static hcd_device_state hcd_device[1];
+
+
+/*===========================================================================*
+ * hcd_handle_event *
+ *===========================================================================*/
+void
+hcd_handle_event(hcd_driver_state * driver)
+{
+ hcd_device_state * this_device;
+
+ DEBUG_DUMP;
+
+ /* TODO: Finding which hcd_device is in use should be performed here */
+ this_device = &(hcd_device[0]);
+
+ /* Sometimes interrupts occur in a weird order (EP after disconnect)
+ * This helps finding ordering errors in DEBUG */
+ USB_DBG("Event: 0x%02X, state: 0x%02X",
+ driver->event, this_device->state);
+
+ /* Set what was received for device thread to use */
+ this_device->driver = driver;
+
+ /* Handle event and forward control to device thread when required */
+ switch (driver->event) {
+ case HCD_EVENT_CONNECTED:
+ if (HCD_STATE_DISCONNECTED == this_device->state) {
+ if (EXIT_SUCCESS != hcd_connect_device(
+ this_device,
+ hcd_device_thread))
+ USB_MSG("Device creation failed");
+ } else
+ USB_MSG("Device not marked as 'disconnected' "
+ "for 'connection' event");
+
+ break;
+
+ case HCD_EVENT_DISCONNECTED:
+ if (HCD_STATE_DISCONNECTED != this_device->state) {
+ /* If connect callback was used before, call
+ * it's equivalent to signal disconnection */
+ if (HCD_STATE_CONNECTED == this_device->state)
+ hcd_disconnect_cb(this_device);
+ hcd_disconnect_device(this_device);
+ this_device->state = HCD_STATE_DISCONNECTED;
+ } else
+ USB_MSG("Device is marked as 'disconnected' "
+ "for 'disconnection' event");
+
+ break;
+
+ case HCD_EVENT_ENDPOINT:
+ /* Allow device thread to continue with it's logic */
+ if (HCD_STATE_DISCONNECTED != this_device->state)
+ hcd_device_continue(this_device);
+ else
+ USB_MSG("Device is marked as 'disconnected' "
+ "for 'EP' event");
+
+ break;
+
+ default:
+ USB_ASSERT(0, "Illegal HCD event");
+ break;
+ }
+}
+
+
+/*===========================================================================*
+ * hcd_device_thread *
+ *===========================================================================*/
+static void
+hcd_device_thread(void * thread_args)
+{
+ hcd_device_state * this_device;
+
+ DEBUG_DUMP;
+
+ /* Retrieve structures from generic data */
+ this_device = (hcd_device_state *)thread_args;
+
+ /* Plugged in */
+ this_device->state = HCD_STATE_CONNECTION_PENDING;
+
+ /* Enumeration sequence */
+ if (EXIT_SUCCESS != hcd_enumerate(this_device))
+ hcd_device_finish(this_device, "USB device enumeration failed");
+
+ /* Tell everyone that device was connected */
+ hcd_connect_cb(this_device);
+
+ /* Fully configured */
+ this_device->state = HCD_STATE_CONNECTED;
+
+ USB_DBG("Waiting for URBs");
+
+ /* No URB's yet */
+ this_device->urb = NULL;
+
+ /* Start handling URB's */
+ for(;;) {
+ /* Block and wait for something like 'submit URB' */
+ hcd_device_wait(this_device);
+
+ if (EXIT_SUCCESS != hcd_handle_urb(this_device))
+ hcd_device_finish(this_device, "URB handling failed");
+ }
+
+ /* Finish device handling to avoid leaving thread */
+ hcd_device_finish(this_device, "USB device handling completed");
+}
+
+
+/*===========================================================================*
+ * hcd_device_finish *
+ *===========================================================================*/
+static void
+hcd_device_finish(hcd_device_state * this_device, const char * finish_msg)
+{
+ DEBUG_DUMP;
+
+ USB_MSG("USB device handling finished with message: '%s'", finish_msg);
+
+ /* Lock forever */
+ for (;;) {
+ hcd_device_wait(this_device);
+ USB_MSG("Failed attempt to continue finished thread");
+ }
+}
+
+
+/*===========================================================================*
+ * hcd_enumerate *
+ *===========================================================================*/
+static int
+hcd_enumerate(hcd_device_state * this_device)
+{
+ hcd_driver_state * d;
+
+ DEBUG_DUMP;
+
+ d = this_device->driver;
+
+ /* First let driver reset device */
+ d->reset_device(d->private_data);
+
+ /* Set parameters for further communication */
+ d->setup_device(d->private_data, HCD_DEFAULT_EP, HCD_DEFAULT_ADDR);
+
+ /* Get device descriptor */
+ if (EXIT_SUCCESS != hcd_get_device_descriptor(this_device)) {
+ USB_MSG("Failed to get device descriptor");
+ return EXIT_FAILURE;
+ }
+
+ /* TODO: dynamic device address when more devices are available */
+
+ /* Set address */
+ if (EXIT_SUCCESS != hcd_set_address(this_device, HCD_ATTACHED_ADDR)) {
+ USB_MSG("Failed to set device address");
+ return EXIT_FAILURE;
+ }
+
+ /* Set parameters for further communication */
+ d->setup_device(d->private_data, HCD_DEFAULT_EP, HCD_ATTACHED_ADDR);
+
+ /* Get other descriptors */
+ if (EXIT_SUCCESS != hcd_get_descriptor_tree(this_device)) {
+ USB_MSG("Failed to get configuration descriptor tree");
+ return EXIT_FAILURE;
+ }
+
+ /* TODO: always first configuration */
+ /* Set configuration */
+ if (EXIT_SUCCESS != hcd_set_configuration(this_device, 0x01)) {
+ USB_MSG("Failed to set configuration");
+ return EXIT_FAILURE;
+ }
+
+ USB_DBG("Enumeration completed");
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_get_device_descriptor *
+ *===========================================================================*/
+static int
+hcd_get_device_descriptor(hcd_device_state * this_device)
+{
+ hcd_ctrlrequest setup;
+
+ DEBUG_DUMP;
+
+ /* TODO: magic numbers, no header for these */
+
+ /* Format setup packet */
+ setup.bRequestType = 0x80; /* IN */
+ setup.bRequest = 0x06; /* Get descriptor */
+ setup.wValue = 0x0100; /* Device */
+ setup.wIndex = 0x0000;
+ setup.wLength = sizeof(this_device->device_desc);
+
+ /* Handle formatted setup packet */
+ if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
+ USB_MSG("Handling setup packet failed");
+ return EXIT_FAILURE;
+ }
+
+ /* Put what was read in device descriptor */
+ memcpy(&(this_device->device_desc), this_device->buffer,
+ sizeof(this_device->device_desc));
+
+ /* Remember max packet size from device descriptor */
+ this_device->max_packet_size = this_device->device_desc.bMaxPacketSize;
+
+ /* Output VID/PID when debugging */
+ USB_DBG("idVendor: %02X%02X", this_device->device_desc.idVendor[1],
+ this_device->device_desc.idVendor[0]);
+ USB_DBG("idProduct: %02X%02X", this_device->device_desc.idProduct[1],
+ this_device->device_desc.idProduct[0]);
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_set_address *
+ *===========================================================================*/
+static int
+hcd_set_address(hcd_device_state * this_device, int address)
+{
+ hcd_ctrlrequest setup;
+
+ DEBUG_DUMP;
+
+ USB_ASSERT((address > 0) && (address < 128), "Illegal address");
+
+ /* TODO: magic numbers, no header for these */
+ setup.bRequestType = 0x00; /* OUT */
+ setup.bRequest = 0x05; /* Set address */
+ setup.wValue = address;
+ setup.wIndex = 0x0000;
+ setup.wLength = 0x0000;
+
+ /* Handle formatted setup packet */
+ if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
+ USB_MSG("Handling setup packet failed");
+ return EXIT_FAILURE;
+ }
+
+ {
+ /* Sleep 5ms for proper addressing */
+ struct timespec nanotm = {0, HCD_NANOSLEEP_MSEC(5)};
+ nanosleep(&nanotm, NULL);
+ }
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_get_descriptor_tree *
+ *===========================================================================*/
+static int
+hcd_get_descriptor_tree(hcd_device_state * this_device)
+{
+ hcd_config_descriptor config_descriptor;
+ hcd_ctrlrequest setup;
+ int completed;
+ int total_length;
+ int buffer_length;
+
+ DEBUG_DUMP;
+
+ /* First, ask only for configuration itself to get length info */
+ buffer_length = sizeof(config_descriptor);
+ completed = 0;
+
+ do {
+ /* TODO: configuration 0 is hard-coded
+ * but others are rarely used anyway */
+ /* TODO: magic numbers, no header for these */
+ setup.bRequestType = 0x80; /* IN */
+ setup.bRequest = 0x06; /* Get descriptor */
+ setup.wValue = 0x0200; /* Configuration 0 */
+ setup.wIndex = 0x0000;
+ setup.wLength = buffer_length;
+
+ /* Handle formatted setup packet */
+ if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
+ USB_MSG("Handling setup packet failed");
+ return EXIT_FAILURE;
+ }
+
+ /* If we only asked for configuration itself
+ * then ask again for other descriptors */
+ if (sizeof(config_descriptor) == buffer_length) {
+
+ /* Put what was read in configuration descriptor */
+ memcpy(&config_descriptor, this_device->buffer,
+ sizeof(config_descriptor));
+
+ /* Continue only if there is more data */
+ total_length = config_descriptor.wTotalLength[0] +
+ (config_descriptor.wTotalLength[1] << 8);
+
+ if (total_length < (int)sizeof(config_descriptor)) {
+ /* This should never happen for a fine device */
+ USB_MSG("Illegal wTotalLength value");
+ return EXIT_FAILURE;
+ }
+ else if (sizeof(config_descriptor) == total_length) {
+ /* Nothing more was in descriptor anyway */
+ completed = 1;
+ }
+ else {
+ /* Read whatever is needed */
+ buffer_length = total_length;
+ }
+
+ } else {
+ /* All data for given configuration was read */
+ completed = 1;
+ }
+ }
+ while (!completed);
+
+ /* Create tree based on received buffer */
+ if (EXIT_SUCCESS != hcd_buffer_to_tree(this_device->buffer,
+ this_device->data_len,
+ &(this_device->config_tree))) {
+ /* This should never happen for a fine device */
+ USB_MSG("Illegal descriptor values");
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_set_configuration *
+ *===========================================================================*/
+static int
+hcd_set_configuration(hcd_device_state * this_device, int configuration)
+{
+ hcd_ctrlrequest setup;
+
+ DEBUG_DUMP;
+
+ /* TODO: magic numbers, no header for these */
+ setup.bRequestType = 0x00; /* OUT */
+ setup.bRequest = 0x09; /* Set configuration */
+ setup.wValue = configuration;
+ setup.wIndex = 0x0000;
+ setup.wLength = 0x0000;
+
+ /* Handle formatted setup packet */
+ if (EXIT_SUCCESS != hcd_setup_packet(this_device, &setup)) {
+ USB_MSG("Handling setup packet failed");
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_handle_urb *
+ *===========================================================================*/
+static int
+hcd_handle_urb(hcd_device_state * this_device)
+{
+ DEBUG_DUMP;
+
+ USB_ASSERT(NULL != this_device->urb, "NULL URB received");
+
+ /* TODO: URB handling will be here */
+
+ /* TODO: call completion */
+ /* hcd_completion_cb */
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_setup_packet *
+ *===========================================================================*/
+static int
+hcd_setup_packet(hcd_device_state * this_device, hcd_ctrlrequest * setup)
+{
+ hcd_driver_state * d;
+ hcd_reg1 * current_byte;
+ int expected_len;
+ int received_len;
+
+ DEBUG_DUMP;
+
+ /* Initially... */
+ d = this_device->driver;
+ expected_len = (int)setup->wLength;
+ current_byte = this_device->buffer;
+
+ /* Send setup packet */
+ d->setup_stage(d->private_data, setup);
+
+ /* Wait for response */
+ hcd_device_wait(this_device);
+
+ /* Check response */
+ if (EXIT_SUCCESS != d->check_error(d->private_data))
+ return EXIT_FAILURE;
+
+ /* For data packets... */
+ if (expected_len > 0) {
+
+ /* TODO: magic number */
+ /* ...IN data packets */
+ if (setup->bRequestType & 0x80) {
+
+ /* What was received until now */
+ this_device->data_len = 0;
+
+ do {
+ /* Try getting data */
+ d->in_data_stage(d->private_data);
+
+ /* Wait for response */
+ hcd_device_wait(this_device);
+
+ /* Check response */
+ if (EXIT_SUCCESS != d->check_error(
+ d->private_data))
+ return EXIT_FAILURE;
+
+ /* Read data received as response */
+ received_len = d->read_data(d->private_data,
+ current_byte, 0);
+
+ /* Data reading should always yield positive
+ * results for proper setup packet */
+ if (received_len > 0) {
+ /* Try next packet */
+ this_device->data_len += received_len;
+ current_byte += received_len;
+ } else
+ return EXIT_FAILURE;
+
+ } while (expected_len > this_device->data_len);
+
+ /* Should be exactly what we requested, no more */
+ if (this_device->data_len != expected_len) {
+ USB_MSG("Received more data than expected");
+ return EXIT_FAILURE;
+ }
+
+ } else {
+ /* TODO: unimplemented */
+ USB_MSG("Illegal non-zero length OUT setup packet");
+ return EXIT_FAILURE;
+ }
+ }
+
+ /* Status stages */
+ if (setup->bRequestType & 0x80) {
+
+ /* Try confirming data receive */
+ d->out_status_stage(d->private_data);
+
+ /* Wait for response */
+ hcd_device_wait(this_device);
+
+ /* Check response */
+ if (EXIT_SUCCESS != d->check_error(d->private_data))
+ return EXIT_FAILURE;
+
+ } else {
+
+ /* Try getting status confirmation */
+ d->in_status_stage(d->private_data);
+
+ /* Wait for response */
+ hcd_device_wait(this_device);
+
+ /* Check response */
+ if (EXIT_SUCCESS != d->check_error(d->private_data))
+ return EXIT_FAILURE;
+
+ /* Read zero data from response to clear registers */
+ if (0 != d->read_data(d->private_data, NULL, 0))
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
--- /dev/null
+/*
+ * Implementation of commonly used procedures for HCD handling/initialization
+ * If possible, everything OS specific should be here
+ */
+
+#include <string.h> /* memset... */
+
+#include <sys/mman.h> /* Physical to virtual memory mapping */
+
+#include <ddekit/interrupt.h> /* DDEKit based interrupt handling */
+
+#include <minix/clkconf.h> /* clkconf_* */
+#include <minix/syslib.h> /* sys_privctl */
+
+#include <usb/hcd_common.h>
+#include <usb/usb_common.h>
+
+
+/*===========================================================================*
+ * Local prototypes *
+ *===========================================================================*/
+static int hcd_fill_configuration(hcd_reg1 *, int, hcd_configuration *, int);
+static int hcd_fill_interface(hcd_reg1 *, int, hcd_interface *, int);
+static int hcd_fill_endpoint(hcd_reg1 *, int, hcd_endpoint *, int);
+
+
+/*===========================================================================*
+ * hcd_os_interrupt_attach *
+ *===========================================================================*/
+int
+hcd_os_interrupt_attach(int irq, void (*init)(void *),
+ void (*isr)(void *), void *priv)
+{
+ DEBUG_DUMP;
+
+ if (NULL == ddekit_interrupt_attach(irq, 0, init, isr, priv)) {
+ USB_MSG("Attaching interrupt %d failed", irq);
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_os_interrupt_detach *
+ *===========================================================================*/
+void
+hcd_os_interrupt_detach(int irq)
+{
+ DEBUG_DUMP;
+ ddekit_interrupt_detach(irq);
+}
+
+
+/*===========================================================================*
+ * hcd_os_interrupt_enable *
+ *===========================================================================*/
+void
+hcd_os_interrupt_enable(int irq)
+{
+ DEBUG_DUMP;
+ ddekit_interrupt_enable(irq);
+}
+
+
+/*===========================================================================*
+ * hcd_os_interrupt_disable *
+ *===========================================================================*/
+void
+hcd_os_interrupt_disable(int irq)
+{
+ DEBUG_DUMP;
+ ddekit_interrupt_disable(irq);
+}
+
+
+/*===========================================================================*
+ * hcd_os_regs_init *
+ *===========================================================================*/
+void *
+hcd_os_regs_init(unsigned long base_addr, unsigned long addr_len)
+{
+ /* Memory range where we need privileged access */
+ struct minix_mem_range mr;
+
+ /* NULL unless initialization was fully completed */
+ void * virt_reg_base;
+
+ DEBUG_DUMP;
+
+ virt_reg_base = NULL;
+
+ /* Must have been set before */
+ USB_ASSERT(0 != base_addr, "Invalid base address!");
+ USB_ASSERT(0 != addr_len, "Invalid base length!");
+
+ /* Set memory range for peripheral */
+ mr.mr_base = base_addr;
+ mr.mr_limit = base_addr + addr_len;
+
+ /* Try getting access to memory range */
+ if (EXIT_SUCCESS == sys_privctl(SELF, SYS_PRIV_ADD_MEM, &mr)) {
+
+ /* And map it where we want it */
+ virt_reg_base = vm_map_phys(SELF, (void *)base_addr, addr_len);
+
+ /* Check for mapping errors to allow us returning NULL */
+ if (MAP_FAILED == virt_reg_base) {
+ USB_MSG("Mapping memory with vm_map_phys() failed");
+ virt_reg_base = NULL;
+ }
+
+ } else
+ USB_MSG("Acquiring memory with sys_privctl() failed");
+
+ return virt_reg_base;
+}
+
+
+/*===========================================================================*
+ * hcd_os_regs_deinit *
+ *===========================================================================*/
+int
+hcd_os_regs_deinit(unsigned long base_addr, unsigned long addr_len)
+{
+ DEBUG_DUMP;
+
+ /* To keep USBD return value convention */
+ return (0 == vm_unmap_phys(SELF, (void*)base_addr, addr_len)) ?
+ EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+
+/*===========================================================================*
+ * hcd_os_clkconf *
+ *===========================================================================*/
+int
+hcd_os_clkconf(unsigned long clk, unsigned long mask, unsigned long value)
+{
+ DEBUG_DUMP;
+
+ /* Apparently clkconf_init may be called more than once anyway */
+ if ((0 == clkconf_init()) && (0 == clkconf_set(clk, mask, value)))
+ return EXIT_SUCCESS;
+ else
+ return EXIT_FAILURE;
+}
+
+
+/*===========================================================================*
+ * hcd_os_clkconf_release *
+ *===========================================================================*/
+int
+hcd_os_clkconf_release(void)
+{
+ DEBUG_DUMP;
+ return clkconf_release();
+}
+
+
+/*===========================================================================*
+ * hcd_init_device *
+ *===========================================================================*/
+int
+hcd_connect_device(hcd_device_state * this_device, hcd_thread_function funct)
+{
+ DEBUG_DUMP;
+
+ if ((NULL != this_device->lock) || (NULL != this_device->thread)) {
+ USB_MSG("Device data already allocated");
+ return EXIT_FAILURE;
+ }
+
+ if (NULL == (this_device->lock = ddekit_sem_init(0)))
+ return EXIT_FAILURE;
+
+ if (NULL == (this_device->thread = ddekit_thread_create(funct,
+ this_device,
+ "Device"))) {
+ ddekit_sem_deinit(this_device->lock);
+ return EXIT_FAILURE;
+ }
+
+ /* Allow device thread to work */
+ ddekit_yield();
+
+ return EXIT_SUCCESS;
+}
+
+/*===========================================================================*
+ * hcd_deinit_device *
+ *===========================================================================*/
+void
+hcd_disconnect_device(hcd_device_state * this_device)
+{
+ DEBUG_DUMP;
+
+ hcd_tree_cleanup(&(this_device->config_tree));
+
+ /* TODO: spilled resources */
+ ddekit_thread_terminate(this_device->thread);
+ ddekit_sem_deinit(this_device->lock);
+
+ this_device->thread = NULL;
+ this_device->lock = NULL;
+}
+
+
+/*===========================================================================*
+ * hcd_device_wait *
+ *===========================================================================*/
+void
+hcd_device_wait(hcd_device_state * this_device)
+{
+ DEBUG_DUMP;
+
+ ddekit_sem_down(this_device->lock);
+}
+
+
+/*===========================================================================*
+ * hcd_device_continue *
+ *===========================================================================*/
+void
+hcd_device_continue(hcd_device_state * this_device)
+{
+ DEBUG_DUMP;
+
+ ddekit_sem_up(this_device->lock);
+}
+
+
+/*===========================================================================*
+ * hcd_buffer_to_tree *
+ *===========================================================================*/
+int
+hcd_buffer_to_tree(hcd_reg1 * buf, int len, hcd_configuration * c)
+{
+ hcd_interface * i;
+ hcd_endpoint * e;
+ hcd_descriptor * desc;
+ int cfg_num;
+ int if_num;
+ int ep_num;
+
+ DEBUG_DUMP;
+
+ cfg_num = 0;
+ if_num = 0;
+ ep_num = 0;
+
+ i = NULL;
+ e = NULL;
+
+ /* Cleanup initially to NULL pointers before any allocation */
+ memset(c, 0, sizeof(*c));
+
+ while (len > (int)sizeof(*desc)) {
+ /* Check descriptor type */
+ desc = (hcd_descriptor *)buf;
+
+ if (UDESC_CONFIG == desc->bDescriptorType) {
+ if (EXIT_SUCCESS != hcd_fill_configuration(buf, len,
+ c, cfg_num++))
+ goto PARSE_ERROR;
+
+ if_num = 0;
+ }
+ else if (UDESC_INTERFACE == desc->bDescriptorType) {
+ if (NULL == c->interface)
+ goto PARSE_ERROR;
+
+ i = &(c->interface[if_num]);
+
+ if (EXIT_SUCCESS != hcd_fill_interface(buf, len,
+ i, if_num++))
+ goto PARSE_ERROR;
+
+ ep_num = 0;
+ }
+ else if (UDESC_ENDPOINT == desc->bDescriptorType) {
+ if (NULL == c->interface)
+ goto PARSE_ERROR;
+
+ if (NULL == i)
+ goto PARSE_ERROR;
+
+ e = &(i->endpoint[ep_num]);
+
+ if (EXIT_SUCCESS != hcd_fill_endpoint(buf, len,
+ e, ep_num++))
+ goto PARSE_ERROR;
+ } else
+ USB_DBG("Unhandled descriptor type 0x%02X",
+ desc->bDescriptorType);
+
+ len -= desc->bLength;
+ buf += desc->bLength;
+ }
+
+ if (0 != len) {
+ USB_MSG("After parsing, some descriptor data remains");
+ goto PARSE_ERROR;
+ }
+
+ return EXIT_SUCCESS;
+
+ PARSE_ERROR:
+ hcd_tree_cleanup(c);
+ return EXIT_FAILURE;
+}
+
+
+/*===========================================================================*
+ * hcd_tree_cleanup *
+ *===========================================================================*/
+void
+hcd_tree_cleanup(hcd_configuration * c)
+{
+ int if_idx;
+
+ DEBUG_DUMP;
+
+ /* Free if anything was allocated */
+ if (NULL != c->interface) {
+
+ USB_ASSERT(c->num_interfaces > 0, "Interface number error");
+
+ for (if_idx = 0; if_idx < c->num_interfaces; if_idx++) {
+ if (NULL != c->interface[if_idx].endpoint) {
+ USB_DBG("Freeing ep for interface #%d", if_idx);
+ free(c->interface[if_idx].endpoint);
+ }
+ }
+
+ USB_DBG("Freeing interfaces");
+ free(c->interface);
+ c->interface = NULL;
+ }
+}
+
+
+/*===========================================================================*
+ * hcd_fill_configuration *
+ *===========================================================================*/
+static int
+hcd_fill_configuration(hcd_reg1 * buf, int len, hcd_configuration * c, int num)
+{
+ hcd_config_descriptor * desc;
+ int interfaces_size;
+
+ DEBUG_DUMP;
+
+ desc = (hcd_config_descriptor *)buf;
+
+ USB_DBG("Configuration #%d", num);
+
+ if (num > 0) {
+ USB_DBG("Only one configuration possible");
+ return EXIT_SUCCESS;
+ }
+
+ if (UDESC_CONFIG != desc->bDescriptorType)
+ return EXIT_FAILURE;
+
+ if (desc->bLength > len)
+ return EXIT_FAILURE;
+
+ if (sizeof(*desc) != desc->bLength)
+ return EXIT_FAILURE;
+
+ memcpy(&(c->descriptor), buf, sizeof(c->descriptor));
+
+ c->num_interfaces = c->descriptor.bNumInterface;
+
+ interfaces_size = c->num_interfaces * sizeof(*(c->interface));
+
+ USB_DBG("Allocating interfaces, %dB", interfaces_size);
+ c->interface = malloc(interfaces_size);
+
+ memset(c->interface, 0, interfaces_size);
+
+ /* Dump configuration in debug mode */
+ USB_DBG("<<CONFIGURATION>>");
+ USB_DBG("bLength %02X", desc->bLength);
+ USB_DBG("bDescriptorType %02X", desc->bDescriptorType);
+ USB_DBG("wTotalLength %02X%02X", desc->wTotalLength[1],
+ desc->wTotalLength[0]);
+ USB_DBG("bNumInterface %02X", desc->bNumInterface);
+ USB_DBG("bConfigurationValue %02X", desc->bConfigurationValue);
+ USB_DBG("iConfiguration %02X", desc->iConfiguration);
+ USB_DBG("bmAttributes %02X", desc->bmAttributes);
+ USB_DBG("bMaxPower %02X", desc->bMaxPower);
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_fill_interface *
+ *===========================================================================*/
+static int
+hcd_fill_interface(hcd_reg1 * buf, int len, hcd_interface * i, int num)
+{
+ hcd_interface_descriptor * desc;
+ int endpoints_size;
+
+ DEBUG_DUMP;
+
+ desc = (hcd_interface_descriptor *)buf;
+
+ USB_DBG("Interface #%d", num);
+
+ if (UDESC_INTERFACE != desc->bDescriptorType)
+ return EXIT_FAILURE;
+
+ if (desc->bLength > len)
+ return EXIT_FAILURE;
+
+ if (sizeof(*desc) != desc->bLength)
+ return EXIT_FAILURE;
+
+ if (desc->bInterfaceNumber != num)
+ return EXIT_FAILURE;
+
+ memcpy(&(i->descriptor), buf, sizeof(i->descriptor));
+
+ i->num_endpoints = i->descriptor.bNumEndpoints;
+
+ endpoints_size = i->num_endpoints * sizeof(*(i->endpoint));
+
+ USB_DBG("Allocating endpoints, %dB", endpoints_size);
+ i->endpoint = malloc(endpoints_size);
+
+ memset(i->endpoint, 0, endpoints_size);
+
+ /* Dump interface in debug mode */
+ USB_DBG("<<INTERFACE>>");
+ USB_DBG("bLength %02X", desc->bLength);
+ USB_DBG("bDescriptorType %02X", desc->bDescriptorType);
+ USB_DBG("bInterfaceNumber %02X", desc->bInterfaceNumber);
+ USB_DBG("bAlternateSetting %02X", desc->bAlternateSetting);
+ USB_DBG("bNumEndpoints %02X", desc->bNumEndpoints);
+ USB_DBG("bInterfaceClass %02X", desc->bInterfaceClass);
+ USB_DBG("bInterfaceSubClass %02X", desc->bInterfaceSubClass);
+ USB_DBG("bInterfaceProtocol %02X", desc->bInterfaceProtocol);
+ USB_DBG("iInterface %02X", desc->iInterface);
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_fill_endpoint *
+ *===========================================================================*/
+static int
+hcd_fill_endpoint(hcd_reg1 * buf, int len, hcd_endpoint * e, int num)
+{
+ hcd_endpoint_descriptor * desc;
+
+ DEBUG_DUMP;
+
+ desc = (hcd_endpoint_descriptor *)buf;
+
+ USB_DBG("Endpoint #%d", num);
+
+ if (UDESC_ENDPOINT != desc->bDescriptorType)
+ return EXIT_FAILURE;
+
+ if (desc->bLength > len)
+ return EXIT_FAILURE;
+
+ if (sizeof(*desc) != desc->bLength)
+ return EXIT_FAILURE;
+
+ memcpy(&(e->descriptor), buf, sizeof(e->descriptor));
+
+ /* Dump endpoint in debug mode */
+ USB_DBG("<<ENDPOINT>>");
+ USB_DBG("bLength %02X", desc->bLength);
+ USB_DBG("bDescriptorType %02X", desc->bDescriptorType);
+ USB_DBG("bEndpointAddress %02X", desc->bEndpointAddress);
+ USB_DBG("bmAttributes %02X", desc->bmAttributes);
+ USB_DBG("wMaxPacketSize %02X%02X", desc->wMaxPacketSize[1],
+ desc->wMaxPacketSize[0]);
+ USB_DBG("bInterval %02X", desc->bInterval);
+
+ return EXIT_SUCCESS;
+}
--- /dev/null
+/*
+ * Implementation of DDEkit related calls/data
+ */
+
+#include <string.h> /* memset */
+
+#include <ddekit/usb.h>
+
+#include <usb/hcd_ddekit.h>
+#include <usb/usb_common.h>
+
+
+/*===========================================================================*
+ * Local declarations *
+ *===========================================================================*/
+/*
+ * In this file "struct ddekit_usb_dev" equals "hcd_device_state"
+ * */
+struct ddekit_usb_device_id;
+struct ddekit_usb_urb;
+struct ddekit_usb_dev;
+
+/*===========================================================================*
+ * Global definitions *
+ *===========================================================================*/
+ddekit_usb_completion_cb completion_cb = NULL;
+ddekit_usb_connect_cb connect_cb = NULL;
+ddekit_usb_disconnect_cb disconnect_cb = NULL;
+
+
+/*===========================================================================*
+ * Implementation for usb_server.c *
+ *===========================================================================*/
+
+/*===========================================================================*
+ * _ddekit_usb_get_manufacturer *
+ *===========================================================================*/
+char *
+_ddekit_usb_get_manufacturer(struct ddekit_usb_dev * ddev)
+{
+ static const char mfg[] = "UNKNOWN";
+ DEBUG_DUMP;
+ /* TODO: UNUSED won't work */
+ ((void)ddev);
+ return (char *)mfg;
+}
+
+
+/*===========================================================================*
+ * _ddekit_usb_get_product *
+ *===========================================================================*/
+char *
+_ddekit_usb_get_product(struct ddekit_usb_dev * ddev)
+{
+ static const char prod[] = "UNKNOWN";
+ DEBUG_DUMP;
+ /* TODO: UNUSED won't work */
+ ((void)ddev);
+ return (char *)prod;
+}
+
+
+/*===========================================================================*
+ * _ddekit_usb_get_serial *
+ *===========================================================================*/
+char *
+_ddekit_usb_get_serial(struct ddekit_usb_dev * ddev)
+{
+ static const char serial[] = "UNKNOWN";
+ DEBUG_DUMP;
+ /* TODO: UNUSED won't work */
+ ((void)ddev);
+ return (char *)serial;
+}
+
+
+/*===========================================================================*
+ * _ddekit_usb_get_device_desc *
+ *===========================================================================*/
+struct usb_device_descriptor *
+_ddekit_usb_get_device_desc(struct ddekit_usb_dev * ddev)
+{
+ hcd_device_state * dev;
+
+ DEBUG_DUMP;
+
+ dev = (hcd_device_state *)ddev;
+
+ return (struct usb_device_descriptor *)
+ (&(dev->config_tree.descriptor));
+}
+
+
+/*===========================================================================*
+ * _ddekit_usb_get_interface_desc *
+ *===========================================================================*/
+struct usb_interface_descriptor *
+_ddekit_usb_get_interface_desc(struct ddekit_usb_dev * ddev, int inum)
+{
+ hcd_device_state * dev;
+
+ DEBUG_DUMP;
+
+ dev = (hcd_device_state *)ddev;
+
+ return (struct usb_interface_descriptor *)
+ (&(dev->config_tree.interface[inum].descriptor));
+}
+
+
+/*===========================================================================*
+ * Implementation for <ddekit/usb.h> *
+ *===========================================================================*/
+
+/*===========================================================================*
+ * ddekit_usb_dev_set_data *
+ *===========================================================================*/
+int
+ddekit_usb_dev_set_data(struct ddekit_usb_dev * dev, void * data)
+{
+ hcd_device_state * hcd_dev;
+
+ DEBUG_DUMP;
+
+ hcd_dev = (hcd_device_state *)dev;
+
+ hcd_dev->data = data;
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * ddekit_usb_dev_get_data *
+ *===========================================================================*/
+void *
+ddekit_usb_dev_get_data(struct ddekit_usb_dev * dev)
+{
+ hcd_device_state * hcd_dev;
+
+ DEBUG_DUMP;
+
+ hcd_dev = (hcd_device_state *)dev;
+
+ return hcd_dev->data;
+}
+
+
+/* TODO: This was in header file but is not used anywhere */
+#if 0
+/*===========================================================================*
+ * ddekit_usb_get_device_id *
+ *===========================================================================*/
+void
+ddekit_usb_get_device_id(struct ddekit_usb_dev * dev,
+ struct ddekit_usb_device_id * id)
+{
+ DEBUG_DUMP;
+ /* TODO: UNUSED won't work */
+ ((void)dev);
+ ((void)id);
+ return;
+}
+#endif
+
+
+/*===========================================================================*
+ * ddekit_usb_submit_urb *
+ *===========================================================================*/
+int
+ddekit_usb_submit_urb(struct ddekit_usb_urb * d_urb)
+{
+ hcd_urb * urb;
+ hcd_device_state * dev;
+
+ DEBUG_DUMP;
+
+ urb = (hcd_urb *)d_urb;
+ dev = (hcd_device_state *)(urb->dev);
+
+ /* TODO: queue URB's */
+ /* Reassign and go to thread */
+ dev->urb = urb;
+ hcd_device_continue(dev);
+ dev->urb = NULL;
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * ddekit_usb_cancle_urb *
+ *===========================================================================*/
+int
+ddekit_usb_cancle_urb(struct ddekit_usb_urb * d_urb)
+{
+ DEBUG_DUMP;
+ /* TODO: UNUSED won't work */
+ ((void)d_urb);
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * ddekit_usb_init *
+ *===========================================================================*/
+int
+ddekit_usb_init(struct ddekit_usb_driver * drv,
+ ddekit_usb_malloc_fn * _m,
+ ddekit_usb_free_fn * _f)
+{
+ DEBUG_DUMP;
+
+ completion_cb = drv->completion;
+ connect_cb = drv->connect;
+ disconnect_cb = drv->disconnect;
+
+ *_m = malloc;
+ *_f = free;
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * hcd_connect_cb *
+ *===========================================================================*/
+void hcd_connect_cb(hcd_device_state * dev)
+{
+ unsigned int if_bitmask;
+
+ DEBUG_DUMP;
+
+ /* TODO: magic numbers like in ddekit/devman */
+ /* Each bit starting from 0, represents valid interface */
+ if_bitmask = 0xFFFFFFFF >> (32 - dev->config_tree.num_interfaces);
+
+ USB_DBG("Interfaces %d, mask %08X",
+ dev->config_tree.num_interfaces,
+ if_bitmask);
+
+ connect_cb((struct ddekit_usb_dev *)dev, (int)if_bitmask);
+}
+
+
+/*===========================================================================*
+ * hcd_disconnect_cb *
+ *===========================================================================*/
+void hcd_disconnect_cb(hcd_device_state * dev)
+{
+ DEBUG_DUMP;
+
+ disconnect_cb((struct ddekit_usb_dev *)dev);
+}
+
+
+/*===========================================================================*
+ * hcd_completion_cb *
+ *===========================================================================*/
+void hcd_completion_cb(void * priv)
+{
+ DEBUG_DUMP;
+
+ completion_cb(priv);
+}
+
+
+/* TODO: to be removed when this is linkable */
+/*===========================================================================*
+ * get_bp *
+ *===========================================================================*/
+unsigned int get_bp(void)
+{
+ DEBUG_DUMP;
+
+ return EXIT_SUCCESS;
+}
--- /dev/null
+/*
+ * Implementation of whatever is hardware specific in AM335x MCU
+ */
+
+#include <string.h> /* memset */
+#include <time.h> /* nanosleep */
+
+#include <usb/hcd_common.h>
+#include <usb/hcd_platforms.h>
+#include <usb/hcd_interface.h>
+#include <usb/usb_common.h>
+
+#include "musb_core.h"
+
+/* TODO: BeagleBone white uses USB0 for PC connection as peripheral */
+#undef AM335X_USE_USB0
+
+
+/*===========================================================================*
+ * AM335x base register defines *
+ *===========================================================================*/
+/* Where MUSB core space starts */
+#define AM335X_MUSB_CORE0_BASE_ADDR 0x47401400u
+#define AM335X_MUSB_CORE1_BASE_ADDR 0x47401C00u
+#define AM335X_MUSB_CORE_BASE_LEN 0x400u
+
+
+/*===========================================================================*
+ * AM335x USB specific register defines *
+ *===========================================================================*/
+/* SS registers base address */
+#define AM335X_USBSS_BASE_ADDR 0x47400000u
+
+#define AM335X_REG_REVREG 0x000u
+#define AM335X_REG_SYSCONFIG 0x010u
+#define AM335X_REG_IRQSTATRAW 0x024u
+#define AM335X_REG_IRQSTAT 0x028u
+#define AM335X_REG_IRQENABLER 0x02Cu
+#define AM335X_REG_IRQCLEARR 0x030u
+#define AM335X_REG_IRQDMATHOLDTX00 0x100u
+#define AM335X_REG_IRQDMATHOLDTX01 0x104u
+#define AM335X_REG_IRQDMATHOLDTX02 0x108u
+#define AM335X_REG_IRQDMATHOLDTX03 0x10Cu
+#define AM335X_REG_IRQDMATHOLDRX00 0x110u
+#define AM335X_REG_IRQDMATHOLDRX01 0x114u
+#define AM335X_REG_IRQDMATHOLDRX02 0x118u
+#define AM335X_REG_IRQDMATHOLDRX03 0x11Cu
+#define AM335X_REG_IRQDMATHOLDTX10 0x120u
+#define AM335X_REG_IRQDMATHOLDTX11 0x124u
+#define AM335X_REG_IRQDMATHOLDTX12 0x128u
+#define AM335X_REG_IRQDMATHOLDTX13 0x12Cu
+#define AM335X_REG_IRQDMATHOLDRX10 0x130u
+#define AM335X_REG_IRQDMATHOLDRX11 0x134u
+#define AM335X_REG_IRQDMATHOLDRX12 0x138u
+#define AM335X_REG_IRQDMATHOLDRX13 0x13Cu
+#define AM335X_REG_IRQDMAENABLE0 0x140u
+#define AM335X_REG_IRQDMAENABLE1 0x144u
+#define AM335X_REG_IRQFRAMETHOLDTX00 0x200u
+#define AM335X_REG_IRQFRAMETHOLDTX01 0x204u
+#define AM335X_REG_IRQFRAMETHOLDTX02 0x208u
+#define AM335X_REG_IRQFRAMETHOLDTX03 0x20Cu
+#define AM335X_REG_IRQFRAMETHOLDRX00 0x210u
+#define AM335X_REG_IRQFRAMETHOLDRX01 0x214u
+#define AM335X_REG_IRQFRAMETHOLDRX02 0x218u
+#define AM335X_REG_IRQFRAMETHOLDRX03 0x21Cu
+#define AM335X_REG_IRQFRAMETHOLDTX10 0x220u
+#define AM335X_REG_IRQFRAMETHOLDTX11 0x224u
+#define AM335X_REG_IRQFRAMETHOLDTX12 0x228u
+#define AM335X_REG_IRQFRAMETHOLDTX13 0x22Cu
+#define AM335X_REG_IRQFRAMETHOLDRX10 0x230u
+#define AM335X_REG_IRQFRAMETHOLDRX11 0x234u
+#define AM335X_REG_IRQFRAMETHOLDRX12 0x238u
+#define AM335X_REG_IRQFRAMETHOLDRX13 0x23Cu
+#define AM335X_REG_IRQFRAMEENABLE0 0x240u
+#define AM335X_REG_IRQFRAMEENABLE1 0x244u
+
+/* Length in bytes of SS registers */
+#define AM335X_USBSS_BASE_LEN AM335X_REG_IRQFRAMEENABLE1 + 4u
+
+/* USBx registers base addresses */
+#define AM335X_USB0_BASE_ADDR 0x47401000u
+#define AM335X_USB1_BASE_ADDR 0x47401800u
+
+#define AM335X_REG_USBXREV 0x00u
+#define AM335X_REG_USBXCTRL 0x14u
+#define AM335X_REG_USBXSTAT 0x18u
+#define AM335X_REG_USBXIRQMSTAT 0x20u
+#define AM335X_REG_USBXIRQSTATRAW0 0x28u
+#define AM335X_REG_USBXIRQSTATRAW1 0x2Cu
+#define AM335X_REG_USBXIRQSTAT0 0x30u
+#define AM335X_REG_USBXIRQSTAT1 0x34u
+#define AM335X_REG_USBXIRQENABLESET0 0x38u
+#define AM335X_REG_USBXIRQENABLESET1 0x3Cu
+#define AM335X_REG_USBXIRQENABLECLR0 0x40u
+#define AM335X_REG_USBXIRQENABLECLR1 0x44u
+#define AM335X_REG_USBXTXMODE 0x70u
+#define AM335X_REG_USBXRXMODE 0x74u
+#define AM335X_REG_USBXGENRNDISEP1 0x80u
+#define AM335X_REG_USBXGENRNDISEP2 0x84u
+#define AM335X_REG_USBXGENRNDISEP3 0x88u
+#define AM335X_REG_USBXGENRNDISEP4 0x8Cu
+#define AM335X_REG_USBXGENRNDISEP5 0x90u
+#define AM335X_REG_USBXGENRNDISEP6 0x94u
+#define AM335X_REG_USBXGENRNDISEP7 0x98u
+#define AM335X_REG_USBXGENRNDISEP8 0x9Cu
+#define AM335X_REG_USBXGENRNDISEP9 0xA0u
+#define AM335X_REG_USBXGENRNDISEP10 0xA4u
+#define AM335X_REG_USBXGENRNDISEP11 0xA8u
+#define AM335X_REG_USBXGENRNDISEP12 0xACu
+#define AM335X_REG_USBXGENRNDISEP13 0xB0u
+#define AM335X_REG_USBXGENRNDISEP14 0xB4u
+#define AM335X_REG_USBXGENRNDISEP15 0xB8u
+#define AM335X_REG_USBXAUTOREQ 0xD0u
+#define AM335X_REG_USBXSRPFIXTIME 0xD4u
+#define AM335X_REG_USBX_TDOWN 0xD8u
+#define AM335X_REG_USBXUTMI 0xE0u
+#define AM335X_REG_USBXMGCUTMILB 0xE4u
+#define AM335X_REG_USBXMODE 0xE8u
+
+/* Values to be set */
+#define AM335X_VAL_USBXCTRL_SOFT_RESET HCD_BIT(0)
+#define AM335X_VAL_USBXCTRL_UINT HCD_BIT(3)
+
+#define AM335X_VAL_USBXMODE_IDDIG_MUX HCD_BIT(7)
+#define AM335X_VAL_USBXMODE_IDDIG HCD_BIT(8)
+
+#define AM335X_VAL_USBXIRQENABLEXXX0_EP0 HCD_BIT(0)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP1 HCD_BIT(1)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP2 HCD_BIT(2)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP3 HCD_BIT(3)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP4 HCD_BIT(4)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP5 HCD_BIT(5)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP6 HCD_BIT(6)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP7 HCD_BIT(7)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP8 HCD_BIT(8)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP9 HCD_BIT(9)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP10 HCD_BIT(10)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP11 HCD_BIT(11)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP12 HCD_BIT(12)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP13 HCD_BIT(13)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP14 HCD_BIT(14)
+#define AM335X_VAL_USBXIRQENABLEXXX0_TX_EP15 HCD_BIT(15)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP1 HCD_BIT(17)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP2 HCD_BIT(18)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP3 HCD_BIT(19)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP4 HCD_BIT(20)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP5 HCD_BIT(21)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP6 HCD_BIT(22)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP7 HCD_BIT(23)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP8 HCD_BIT(24)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP9 HCD_BIT(25)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP10 HCD_BIT(26)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP11 HCD_BIT(27)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP12 HCD_BIT(28)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP13 HCD_BIT(29)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP14 HCD_BIT(30)
+#define AM335X_VAL_USBXIRQENABLEXXX0_RX_EP15 HCD_BIT(31)
+
+#define AM335X_VAL_USBXIRQENABLEXXX1_SUSPEND HCD_BIT(0)
+#define AM335X_VAL_USBXIRQENABLEXXX1_RESUME HCD_BIT(1)
+#define AM335X_VAL_USBXIRQENABLEXXX1_RESET_BABBLE HCD_BIT(2)
+#define AM335X_VAL_USBXIRQENABLEXXX1_SOF HCD_BIT(3)
+#define AM335X_VAL_USBXIRQENABLEXXX1_CONNECTED HCD_BIT(4)
+#define AM335X_VAL_USBXIRQENABLEXXX1_DISCONNECTED HCD_BIT(5)
+#define AM335X_VAL_USBXIRQENABLEXXX1_SRP HCD_BIT(6)
+#define AM335X_VAL_USBXIRQENABLEXXX1_VBUS HCD_BIT(7)
+#define AM335X_VAL_USBXIRQENABLEXXX1_DRVVBUS HCD_BIT(8)
+#define AM335X_VAL_USBXIRQENABLEXXX1_GENERIC HCD_BIT(9)
+
+#define AM335X_VAL_USBXIRQSTAT1_SUSPEND HCD_BIT(0)
+#define AM335X_VAL_USBXIRQSTAT1_RESUME HCD_BIT(1)
+#define AM335X_VAL_USBXIRQSTAT1_RESET_BABBLE HCD_BIT(2)
+#define AM335X_VAL_USBXIRQSTAT1_SOF HCD_BIT(3)
+#define AM335X_VAL_USBXIRQSTAT1_CONNECTED HCD_BIT(4)
+#define AM335X_VAL_USBXIRQSTAT1_DISCONNECTED HCD_BIT(5)
+#define AM335X_VAL_USBXIRQSTAT1_SRP HCD_BIT(6)
+#define AM335X_VAL_USBXIRQSTAT1_VBUS HCD_BIT(7)
+#define AM335X_VAL_USBXIRQSTAT1_DRVVBUS HCD_BIT(8)
+#define AM335X_VAL_USBXIRQSTAT1_GENERIC HCD_BIT(9)
+
+/* Length in bytes of USBx registers */
+#define AM335X_USBX_BASE_LEN AM335X_REG_USBXMODE + 4u
+
+/* Helpers for interrupt clearing */
+#define CLEAR_IRQ0(irq0_bit) HCD_WR4(r, AM335X_REG_USBXIRQSTAT0, (irq0_bit))
+#define CLEAR_IRQ1(irq1_bit) HCD_WR4(r, AM335X_REG_USBXIRQSTAT1, (irq1_bit))
+
+
+/*===========================================================================*
+ * AM335x clocking register defines *
+ *===========================================================================*/
+/* Clock module registers offsets */
+#define AM335X_CM_PER_BASE_OFFSET 0x00u
+#define AM335X_REG_CM_PER_USB0_CLKCTRL (AM335X_CM_PER_BASE_OFFSET + 28u)
+
+/* Possible values to be set */
+#define AM335X_VAL_CM_PER_USB0_CLKCTRL_MODULEMODE_ENABLE 0x2u
+#define AM335X_CLKCONF_FULL_VAL 0xFFFFFFFFu
+
+
+/*===========================================================================*
+ * AM335x USB configuration structures *
+ *===========================================================================*/
+#define AM335X_USBSS_IRQ 17
+#define AM335X_USB0_IRQ 18
+#define AM335X_USB1_IRQ 19
+
+/* Hardware configuration values specific to AM335X USBSS (USB Subsystem) */
+typedef struct am335x_ss_config {
+
+ void * regs; /* Points to beginning of memory mapped register space */
+}
+am335x_ss_config;
+
+/* Hardware configuration values specific to AM335X USB(0,1) OTG */
+typedef struct am335x_usbX_config {
+
+ void * regs; /* Points to beginning of memory mapped register space */
+}
+am335x_usbX_config;
+
+/* Private data for AM335X's IRQ thread */
+typedef struct am335x_irq_private {
+
+ int usb_num; /* Number of currently handled controller (0, 1) */
+}
+am335x_irq_private;
+
+/* Single MUSB peripheral information */
+typedef struct am335x_controller {
+
+ am335x_irq_private priv;
+ am335x_usbX_config usb;
+ musb_core_config core;
+ hcd_driver_state driver;
+}
+am335x_controller;
+
+#define AM335X_NUM_USB_CONTROLLERS 2
+#define AM335X_USB0 0
+#define AM335X_USB1 1
+
+/* Configuration values specific to AM335X... */
+typedef struct am335x_config {
+
+ am335x_ss_config ss;
+ am335x_controller ctrl[AM335X_NUM_USB_CONTROLLERS];
+}
+am335x_config;
+
+/* ...and their current holder */
+static am335x_config am335x;
+
+
+/*===========================================================================*
+ * Local declarations *
+ *===========================================================================*/
+/* Basic functionality */
+static int musb_am335x_internal_init(void);
+static void musb_am335x_internal_deinit(void);
+
+/* Interrupt related */
+static void musb_am335x_irq_init(void *); /* TODO: required by DDEKit */
+static void musb_am335x_usbss_isr(void *);
+static void musb_am335x_usbx_isr(void *);
+
+/* Configuration helpers */
+static void musb_am335x_usb_reset(int);
+static void musb_am335x_otg_enable(int);
+
+
+/*===========================================================================*
+ * musb_am335x_init *
+ *===========================================================================*/
+int
+musb_am335x_init(void)
+{
+ am335x_controller * ctrl;
+
+ DEBUG_DUMP;
+
+ /* Initial cleanup */
+ memset(&am335x, 0, sizeof(am335x));
+
+ /* These registers are specific to AM335X so they are mapped here */
+ /* -------------------------------------------------------------- */
+ /* USBSS -------------------------------------------------------- */
+ /* -------------------------------------------------------------- */
+
+ /* Map memory for USBSS */
+ am335x.ss.regs = hcd_os_regs_init(AM335X_USBSS_BASE_ADDR,
+ AM335X_USBSS_BASE_LEN);
+
+ if (NULL == am335x.ss.regs)
+ return EXIT_FAILURE;
+
+ /* Attach IRQ to number */
+ if (EXIT_SUCCESS != hcd_os_interrupt_attach(AM335X_USBSS_IRQ,
+ musb_am335x_irq_init,
+ musb_am335x_usbss_isr,
+ NULL))
+ return EXIT_FAILURE;
+
+#ifdef AM335X_USE_USB0
+ /* -------------------------------------------------------------- */
+ /* USB0 --------------------------------------------------------- */
+ /* -------------------------------------------------------------- */
+ {
+ ctrl = &(am335x.ctrl[AM335X_USB0]);
+
+ /* IRQ thread private data */
+ ctrl->priv.usb_num = AM335X_USB0;
+
+ /* MUSB core addresses for later registering */
+ ctrl->core.regs = hcd_os_regs_init(AM335X_MUSB_CORE0_BASE_ADDR,
+ AM335X_MUSB_CORE_BASE_LEN);
+
+ if (NULL == ctrl->core.regs)
+ return EXIT_FAILURE;
+
+ /* Map AM335X USB0 specific addresses */
+ ctrl->usb.regs = hcd_os_regs_init(AM335X_USB0_BASE_ADDR,
+ AM335X_USBX_BASE_LEN);
+
+ if (NULL == ctrl->usb.regs)
+ return EXIT_FAILURE;
+
+ /* Attach IRQ to number */
+ if (EXIT_SUCCESS != hcd_os_interrupt_attach(AM335X_USB0_IRQ,
+ musb_am335x_irq_init,
+ musb_am335x_usbx_isr,
+ &(ctrl->priv)))
+ return EXIT_FAILURE;
+
+ /* Initialize HCD driver */
+ ctrl->driver.private_data = &(ctrl->core);
+ ctrl->driver.setup_device = musb_setup_device;
+ ctrl->driver.reset_device = musb_reset_device;
+ ctrl->driver.setup_stage = musb_setup_stage;
+ ctrl->driver.in_data_stage = musb_in_data_stage;
+ ctrl->driver.out_data_stage = musb_out_data_stage;
+ ctrl->driver.in_status_stage = musb_in_status_stage;
+ ctrl->driver.out_status_stage = musb_out_status_stage;
+ ctrl->driver.read_data = musb_read_data;
+ ctrl->driver.check_error = musb_check_error;
+ }
+#endif
+
+ /* -------------------------------------------------------------- */
+ /* USB1 --------------------------------------------------------- */
+ /* -------------------------------------------------------------- */
+ {
+ ctrl = &(am335x.ctrl[AM335X_USB1]);
+
+ /* IRQ thread private data */
+ ctrl->priv.usb_num = AM335X_USB1;
+
+ /* MUSB core addresses for later registering */
+ ctrl->core.regs = hcd_os_regs_init(AM335X_MUSB_CORE1_BASE_ADDR,
+ AM335X_MUSB_CORE_BASE_LEN);
+
+ if (NULL == ctrl->core.regs)
+ return EXIT_FAILURE;
+
+ /* Map AM335X USB1 specific addresses */
+ ctrl->usb.regs = hcd_os_regs_init(AM335X_USB1_BASE_ADDR,
+ AM335X_USBX_BASE_LEN);
+
+ if (NULL == ctrl->usb.regs)
+ return EXIT_FAILURE;
+
+ /* Attach IRQ to number */
+ if (EXIT_SUCCESS != hcd_os_interrupt_attach(AM335X_USB1_IRQ,
+ musb_am335x_irq_init,
+ musb_am335x_usbx_isr,
+ &(ctrl->priv)))
+ return EXIT_FAILURE;
+
+ /* Initialize HCD driver */
+ ctrl->driver.private_data = &(ctrl->core);
+ ctrl->driver.setup_device = musb_setup_device;
+ ctrl->driver.reset_device = musb_reset_device;
+ ctrl->driver.setup_stage = musb_setup_stage;
+ ctrl->driver.in_data_stage = musb_in_data_stage;
+ ctrl->driver.out_data_stage = musb_out_data_stage;
+ ctrl->driver.in_status_stage = musb_in_status_stage;
+ ctrl->driver.out_status_stage = musb_out_status_stage;
+ ctrl->driver.read_data = musb_read_data;
+ ctrl->driver.check_error = musb_check_error;
+ }
+
+ return musb_am335x_internal_init();
+}
+
+
+/*===========================================================================*
+ * musb_am335x_deinit *
+ *===========================================================================*/
+void
+musb_am335x_deinit(void)
+{
+ DEBUG_DUMP;
+
+ musb_am335x_internal_deinit();
+
+ /* Release maps if anything was assigned */
+#ifdef AM335X_USE_USB0
+ if (NULL != am335x.ctrl[AM335X_USB0].usb.regs)
+ if (EXIT_SUCCESS != hcd_os_regs_deinit(AM335X_USB0_BASE_ADDR,
+ AM335X_USBX_BASE_LEN))
+ USB_MSG("Failed to release USB0 OTG mapping");
+
+ if (NULL != am335x.ctrl[AM335X_USB0].core.regs)
+ if (EXIT_SUCCESS != hcd_os_regs_deinit(
+ AM335X_MUSB_CORE0_BASE_ADDR,
+ AM335X_MUSB_CORE_BASE_LEN))
+ USB_MSG("Failed to release USB0 core mapping");
+#endif
+ if (NULL != am335x.ctrl[AM335X_USB1].usb.regs)
+ if (EXIT_SUCCESS != hcd_os_regs_deinit(AM335X_USB1_BASE_ADDR,
+ AM335X_USBX_BASE_LEN))
+ USB_MSG("Failed to release USB1 OTG mapping");
+
+ if (NULL != am335x.ctrl[AM335X_USB1].core.regs)
+ if (EXIT_SUCCESS != hcd_os_regs_deinit(
+ AM335X_MUSB_CORE1_BASE_ADDR,
+ AM335X_MUSB_CORE_BASE_LEN))
+ USB_MSG("Failed to release USB1 core mapping");
+
+ if (NULL != am335x.ss.regs)
+ if (EXIT_SUCCESS != hcd_os_regs_deinit(AM335X_USBSS_BASE_ADDR,
+ AM335X_USBSS_BASE_LEN))
+ USB_MSG("Failed to release USBSS mapping");
+}
+
+
+/*===========================================================================*
+ * musb_am335x_internal_init *
+ *===========================================================================*/
+static int
+musb_am335x_internal_init(void)
+{
+ DEBUG_DUMP;
+
+ /* Configure clocking */
+ if (hcd_os_clkconf(AM335X_REG_CM_PER_USB0_CLKCTRL,
+ AM335X_VAL_CM_PER_USB0_CLKCTRL_MODULEMODE_ENABLE,
+ AM335X_CLKCONF_FULL_VAL))
+ return EXIT_FAILURE;
+
+ /* TODO: time to stabilize? */
+ {
+ /* Sleep 25ms */
+ struct timespec nanotm = {0, HCD_NANOSLEEP_MSEC(25)};
+ nanosleep(&nanotm, NULL);
+ }
+
+ /* Read and dump revision register */
+ USB_MSG("Revision (REVREG): %08X",
+ (unsigned int)HCD_RD4(am335x.ss.regs, AM335X_REG_REVREG));
+
+ /* Allow OS to handle previously configured USBSS interrupts */
+ hcd_os_interrupt_enable(AM335X_USBSS_IRQ);
+
+#ifdef AM335X_USE_USB0
+ /* Reset controllers so we get default register values */
+ musb_am335x_usb_reset(AM335X_USB0);
+ /* Allow OS to handle previously configured USB0 interrupts */
+ hcd_os_interrupt_enable(AM335X_USB0_IRQ);
+ /* Enable whatever necessary for OTG part of controller */
+ musb_am335x_otg_enable(AM335X_USB0);
+ /* Configure control endpoint EP0 */
+ musb_ep0_config(&(am335x.ctrl[AM335X_USB0].core));
+ /* Start actual MUSB core */
+ musb_core_start(&(am335x.ctrl[AM335X_USB0].core));
+#endif
+
+ /* Reset controllers so we get default register values */
+ musb_am335x_usb_reset(AM335X_USB1);
+ /* Allow OS to handle previously configured USB1 interrupts */
+ hcd_os_interrupt_enable(AM335X_USB1_IRQ);
+ /* Enable whatever necessary for OTG part of controller */
+ musb_am335x_otg_enable(AM335X_USB1);
+ /* Configure control endpoint EP0 */
+ musb_ep0_config(&(am335x.ctrl[AM335X_USB1].core));
+ /* Start actual MUSB core */
+ musb_core_start(&(am335x.ctrl[AM335X_USB1].core));
+
+ return EXIT_SUCCESS;
+}
+
+
+/*===========================================================================*
+ * musb_am335x_internal_deinit *
+ *===========================================================================*/
+static void
+musb_am335x_internal_deinit(void)
+{
+ DEBUG_DUMP;
+
+ /* Disable all interrupts */
+ hcd_os_interrupt_disable(AM335X_USBSS_IRQ);
+#ifdef AM335X_USE_USB0
+ hcd_os_interrupt_disable(AM335X_USB0_IRQ);
+#endif
+ hcd_os_interrupt_disable(AM335X_USB1_IRQ);
+
+ /* Stop core */
+#ifdef AM335X_USE_USB0
+ musb_core_stop(&(am335x.ctrl[AM335X_USB0].core));
+#endif
+ musb_core_stop(&(am335x.ctrl[AM335X_USB1].core));
+
+ /* Every clkconf call should have corresponding release */
+ hcd_os_clkconf_release();
+}
+
+
+/*===========================================================================*
+ * musb_am335x_irq_init *
+ *===========================================================================*/
+static void
+musb_am335x_irq_init(void * UNUSED(unused))
+{
+ DEBUG_DUMP;
+}
+
+
+/*===========================================================================*
+ * musb_am335x_usbss_isr *
+ *===========================================================================*/
+static void
+musb_am335x_usbss_isr(void * UNUSED(data))
+{
+ void * r;
+ hcd_reg4 irqstat;
+
+ DEBUG_DUMP;
+
+ r = am335x.ss.regs;
+
+ irqstat = HCD_RD4(r, AM335X_REG_IRQSTAT);
+
+ USB_DBG("AM335X_REG_IRQSTAT = %X", (unsigned int)irqstat);
+
+ /* Write to clear interrupt */
+ HCD_WR4(r, AM335X_REG_IRQSTAT, irqstat);
+}
+
+
+/*===========================================================================*
+ * musb_am335x_usbx_isr *
+ *===========================================================================*/
+static void
+musb_am335x_usbx_isr(void * data)
+{
+ void * r;
+ hcd_driver_state * driver;
+ hcd_reg4 irqstat0;
+ hcd_reg4 irqstat1;
+ int usb_num;
+
+ DEBUG_DUMP;
+
+ /* Prepare locals based on USB controller number for this interrupt */
+ usb_num = ((am335x_irq_private*)data)->usb_num;
+ r = am335x.ctrl[usb_num].usb.regs;
+ driver = &(am335x.ctrl[usb_num].driver);
+
+ /* Read, handle and clean interrupts */
+ irqstat0 = HCD_RD4(r, AM335X_REG_USBXIRQSTAT0);
+ irqstat1 = HCD_RD4(r, AM335X_REG_USBXIRQSTAT1);
+
+ /* TODO: priority of interrupts */
+ if (irqstat1 & AM335X_VAL_USBXIRQSTAT1_DRVVBUS) {
+ USB_DBG("DRVVBUS level changed");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQSTAT1_DRVVBUS);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_CONNECTED) {
+ USB_DBG("Device connected");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_CONNECTED);
+ driver->event = HCD_EVENT_CONNECTED;
+ driver->subevent = HCD_SUBEVENT_NONE;
+ hcd_handle_event(driver);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_DISCONNECTED) {
+ USB_DBG("Device disconnected");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_DISCONNECTED);
+ driver->event = HCD_EVENT_DISCONNECTED;
+ driver->subevent = HCD_SUBEVENT_NONE;
+ hcd_handle_event(driver);
+ return;
+ }
+
+ if (irqstat0 & 0x01) {
+ USB_DBG("EP0 interrupt");
+ CLEAR_IRQ0(0x01);
+ driver->event = HCD_EVENT_ENDPOINT;
+ driver->subevent = HCD_SUBEVENT_EP0;
+ hcd_handle_event(driver);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_SUSPEND) {
+ USB_DBG("Unhandled SUSPEND IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_SUSPEND);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_RESUME) {
+ USB_DBG("Unhandled RESUME IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_RESUME);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_RESET_BABBLE) {
+ USB_DBG("Unhandled RESET/BABBLE IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_RESET_BABBLE);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_SOF) {
+ USB_DBG("Unhandled SOF IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_SOF);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_SRP) {
+ USB_DBG("Unhandled SRP IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_SRP);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_VBUS) {
+ USB_DBG("Unhandled VBUS IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_VBUS);
+ return;
+ }
+
+ if (irqstat1 & AM335X_VAL_USBXIRQENABLEXXX1_GENERIC) {
+ USB_DBG("Unhandled GENERIC IRQ");
+ CLEAR_IRQ1(AM335X_VAL_USBXIRQENABLEXXX1_GENERIC);
+ return;
+ }
+
+ /* When controller is correctly configured this should never happen: */
+ USB_MSG("Illegal value of IRQxSTAT: 0=%X 1=%X",
+ (unsigned int)irqstat0, (unsigned int)irqstat1);
+ USB_ASSERT(0, "IRQxSTAT error");
+}
+
+
+/*===========================================================================*
+ * musb_am335x_usb_reset *
+ *===========================================================================*/
+static void
+musb_am335x_usb_reset(int usb_num)
+{
+ void * r;
+ hcd_reg4 ctrl;
+
+ DEBUG_DUMP;
+
+ r = am335x.ctrl[usb_num].usb.regs;
+
+ /* Set SOFT_RESET bit and wait until it is off */
+ ctrl = HCD_RD4(r, AM335X_REG_USBXCTRL);
+ HCD_SET(ctrl, AM335X_VAL_USBXCTRL_SOFT_RESET);
+ HCD_WR4(r, AM335X_REG_USBXCTRL, ctrl);
+ while (HCD_RD4(r, AM335X_REG_USBXCTRL) &
+ AM335X_VAL_USBXCTRL_SOFT_RESET);
+}
+
+
+/*===========================================================================*
+ * musb_am335x_otg_enable *
+ *===========================================================================*/
+static void
+musb_am335x_otg_enable(int usb_num)
+{
+ void * r;
+ hcd_reg4 intreg;
+ hcd_reg4 mode;
+
+ DEBUG_DUMP;
+
+ r = am335x.ctrl[usb_num].usb.regs;
+
+ /* Force host operation */
+ mode = HCD_RD4(r, AM335X_REG_USBXMODE);
+ HCD_SET(mode, AM335X_VAL_USBXMODE_IDDIG_MUX);
+ HCD_CLR(mode, AM335X_VAL_USBXMODE_IDDIG);
+ HCD_WR4(r, AM335X_REG_USBXMODE, mode);
+
+ /* Set all important interrupts to be handled */
+ intreg = HCD_RD4(r, AM335X_REG_USBXIRQENABLESET1);
+ HCD_SET(intreg, AM335X_VAL_USBXIRQENABLEXXX1_SUSPEND |
+ AM335X_VAL_USBXIRQENABLEXXX1_RESUME |
+ AM335X_VAL_USBXIRQENABLEXXX1_RESET_BABBLE |
+ /* AM335X_VAL_USBXIRQENABLEXXX1_SOF | */
+ AM335X_VAL_USBXIRQENABLEXXX1_CONNECTED |
+ AM335X_VAL_USBXIRQENABLEXXX1_DISCONNECTED |
+ AM335X_VAL_USBXIRQENABLEXXX1_SRP |
+ AM335X_VAL_USBXIRQENABLEXXX1_VBUS |
+ AM335X_VAL_USBXIRQENABLEXXX1_DRVVBUS |
+ AM335X_VAL_USBXIRQENABLEXXX1_GENERIC);
+
+ HCD_WR4(r, AM335X_REG_USBXIRQENABLESET1, intreg);
+
+ /* Set endpoint 0 interrupt to be enabled */
+ intreg = HCD_RD4(r, AM335X_REG_USBXIRQENABLESET0);
+ HCD_SET(intreg, AM335X_VAL_USBXIRQENABLEXXX0_EP0);
+ HCD_WR4(r, AM335X_REG_USBXIRQENABLESET0, intreg);
+}
--- /dev/null
+/*
+ * Implementation of low level MUSB core logic (variant independent)
+ */
+
+#include <string.h> /* memcpy */
+#include <time.h> /* nanosleep */
+
+#include <usb/hcd_common.h>
+#include <usb/hcd_interface.h>
+#include <usb/usb_common.h>
+
+#include "musb_core.h"
+#include "musb_regs.h"
+
+
+/*===========================================================================*
+ * Local defines *
+ *===========================================================================*/
+#define HCD_COPYBUF_BYTES 64 /* Stack allocated, must be multiple of 4 */
+#define HCD_COPYBUF_WORDS (HCD_COPYBUF_BYTES/4)
+
+
+/*===========================================================================*
+ * Local prototypes *
+ *===========================================================================*/
+static void musb_set_state(musb_core_config *);
+static int musb_check_rxpktrdy(void *);
+static void musb_in_stage_cleanup(void *);
+static void musb_clear_rxpktrdy(void *);
+static void musb_clear_statuspkt(void *);
+static int musb_get_count(void *);
+static void musb_read_fifo(void *, hcd_reg1 *, int, int);
+
+
+/*===========================================================================*
+ * *
+ * MUSB core implementation *
+ * *
+ *===========================================================================*/
+
+/*===========================================================================*
+ * musb_set_state *
+ *===========================================================================*/
+static void
+musb_set_state(musb_core_config * cfg)
+{
+ void * r;
+ hcd_reg1 idx;
+
+ DEBUG_DUMP;
+
+ r = cfg->regs;
+
+ /* Set EP and address to be used in next MUSB command */
+
+ /* Set EP by selecting INDEX */
+ idx = HCD_RD1(r, MUSB_REG_INDEX);
+ HCD_CLR(idx, 0x0F);
+ HCD_SET(idx, cfg->ep & 0x0F);
+ HCD_WR1(r, MUSB_REG_INDEX, idx);
+
+ /* Use device with address 'cfg->addr' */
+ HCD_WR2(r, MUSB_REG_RXFUNCADDR, cfg->addr);
+ HCD_WR2(r, MUSB_REG_TXFUNCADDR, cfg->addr);
+}
+
+
+/*===========================================================================*
+ * musb_check_rxpktrdy *
+ *===========================================================================*/
+static int
+musb_check_rxpktrdy(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Check for RXPKTRDY */
+ if (host_csr0 & MUSB_VAL_HOST_CSR0_RXPKTRDY)
+ return EXIT_SUCCESS;
+
+ return EXIT_FAILURE;
+}
+
+
+/*===========================================================================*
+ * musb_in_stage_cleanup *
+ *===========================================================================*/
+static void
+musb_in_stage_cleanup(void * cfg)
+{
+ DEBUG_DUMP;
+
+ musb_clear_rxpktrdy(cfg);
+ musb_clear_statuspkt(cfg);
+}
+
+
+/*===========================================================================*
+ * musb_clear_rxpktrdy *
+ *===========================================================================*/
+static void
+musb_clear_rxpktrdy(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Clear RXPKTRDY to signal receive completion */
+ HCD_CLR(host_csr0, MUSB_VAL_HOST_CSR0_RXPKTRDY);
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+}
+
+
+/*===========================================================================*
+ * musb_clear_statuspkt *
+ *===========================================================================*/
+static void
+musb_clear_statuspkt(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Clear STATUSPKT to signal status packet completion */
+ HCD_CLR(host_csr0, MUSB_VAL_HOST_CSR0_STATUSPKT);
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+}
+
+
+/*===========================================================================*
+ * musb_get_count *
+ *===========================================================================*/
+static int
+musb_get_count(void * cfg)
+{
+ void * r;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Reserved part returns zero so no need to generalize
+ * this return for MUSB_REG_RXCOUNT */
+ return (int)(HCD_RD2(r, MUSB_REG_COUNT0));
+}
+
+
+/*===========================================================================*
+ * musb_read_fifo *
+ *===========================================================================*/
+static void
+musb_read_fifo(void * cfg, hcd_reg1 * output, int size, int fifo_num)
+{
+ void * r;
+ hcd_reg4 * word;
+ hcd_reg4 copy_buf[HCD_COPYBUF_WORDS];
+ hcd_addr fifo_addr;
+ int limit;
+ int idx;
+
+ DEBUG_DUMP;
+
+ USB_ASSERT((fifo_num >= 0) && (fifo_num <= 4), "Wrong FIFO number");
+
+ r = ((musb_core_config *)cfg)->regs;
+ fifo_addr = MUSB_REG_FIFO0 + (fifo_num * MUSB_REG_FIFO_LEN);
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Read full words from MUSB FIFO */
+ while (size > 0) {
+ /* Largest amount of bytes that can be copied at a time */
+ limit = (size < HCD_COPYBUF_BYTES) ? size : HCD_COPYBUF_BYTES;
+
+ /* Start copying into that */
+ word = copy_buf;
+
+ /* Read words from FIFO into copy_buf */
+ for (idx = 0; idx < limit; idx += sizeof(*word))
+ *word++ = HCD_RD4(r, fifo_addr);
+
+ /* Copy and shift */
+ memcpy(output, copy_buf, limit);
+ output += limit;
+ size -= limit;
+ }
+}
+
+
+/*===========================================================================*
+ * musb_core_start *
+ *===========================================================================*/
+void
+musb_core_start(void * cfg)
+{
+ void * r;
+ hcd_reg1 devctl;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Enable all interrupts valid for host */
+ HCD_WR1(r, MUSB_REG_INTRUSBE,
+ MUSB_VAL_INTRUSBE_SUSPEND |
+ MUSB_VAL_INTRUSBE_RESUME |
+ MUSB_VAL_INTRUSBE_RESET_BABBLE |
+ /* MUSB_VAL_INTRUSBE_SOF | */
+ MUSB_VAL_INTRUSBE_CONN |
+ MUSB_VAL_INTRUSBE_DISCON |
+ MUSB_VAL_INTRUSBE_SESSREQ |
+ MUSB_VAL_INTRUSBE_VBUSERR);
+
+ /* Start session */
+ devctl = HCD_RD1(r, MUSB_REG_DEVCTL);
+ HCD_SET(devctl, MUSB_VAL_DEVCTL_SESSION);
+ HCD_WR1(r, MUSB_REG_DEVCTL, devctl);
+}
+
+
+/*===========================================================================*
+ * musb_core_stop *
+ *===========================================================================*/
+void
+musb_core_stop(void * cfg)
+{
+ void * r;
+ hcd_reg1 devctl;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* TODO: add hardware interrupt disable */
+
+ /* Stop session */
+ devctl = HCD_RD1(r, MUSB_REG_DEVCTL);
+ HCD_CLR(devctl, MUSB_VAL_DEVCTL_SESSION);
+ HCD_WR1(r, MUSB_REG_DEVCTL, devctl);
+}
+
+
+/*===========================================================================*
+ * musb_ep0_config *
+ *===========================================================================*/
+void
+musb_ep0_config(void * cfg)
+{
+ void * r;
+ hcd_reg1 host_type0;
+ hcd_reg2 intrtxe;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set parameters temporarily */
+ musb_setup_device((musb_core_config *)cfg,
+ HCD_DEFAULT_EP,
+ HCD_DEFAULT_ADDR);
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Set high speed for EP0 */
+ host_type0 = HCD_RD1(r, MUSB_REG_HOST_TYPE0);
+ HCD_CLR(host_type0, MUSB_VAL_HOST_TYPE0_MASK);
+ HCD_SET(host_type0, MUSB_VAL_HOST_TYPE0_HIGH_SPEED);
+ HCD_WR1(r, MUSB_REG_HOST_TYPE0, host_type0);
+
+ /* Enable EP interrupt */
+ intrtxe = HCD_RD2(r, MUSB_REG_INTRTXE);
+ HCD_SET(intrtxe, MUSB_VAL_INTRTXE_EP0);
+ HCD_WR2(r, MUSB_REG_INTRTXE, intrtxe);
+}
+
+
+/*===========================================================================*
+ * *
+ * HCD interface implementation *
+ * *
+ *===========================================================================*/
+
+/*===========================================================================*
+ * musb_setup_device *
+ *===========================================================================*/
+void
+musb_setup_device(void * cfg, hcd_reg1 ep, hcd_reg1 addr)
+{
+ DEBUG_DUMP;
+
+ /* Assign */
+ ((musb_core_config *)cfg)->ep = ep;
+ ((musb_core_config *)cfg)->addr = addr;
+}
+
+
+/*===========================================================================*
+ * musb_reset_device *
+ *===========================================================================*/
+void
+musb_reset_device(void * cfg)
+{
+ void * r;
+ hcd_reg1 power;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Write reset bit and high speed negotiation wait for at least
+ * 20ms for reset, clear reset bit and wait for device */
+ power = HCD_RD1(r, MUSB_REG_POWER);
+ HCD_SET(power, MUSB_VAL_POWER_RESET | MUSB_VAL_POWER_HSEN);
+ HCD_WR1(r, MUSB_REG_POWER, power);
+
+ {
+ /* Sleep 25ms */
+ struct timespec nanotm = {0, HCD_NANOSLEEP_MSEC(25)};
+ nanosleep(&nanotm, NULL);
+ }
+
+ power = HCD_RD1(r, MUSB_REG_POWER);
+ HCD_CLR(power, MUSB_VAL_POWER_RESET);
+ HCD_WR1(r, MUSB_REG_POWER, power);
+
+ {
+ /* Sleep 25ms */
+ struct timespec nanotm = {0, HCD_NANOSLEEP_MSEC(25)};
+ nanosleep(&nanotm, NULL);
+ }
+}
+
+
+/*===========================================================================*
+ * musb_setup_stage *
+ *===========================================================================*/
+void
+musb_setup_stage(void * cfg, hcd_ctrlrequest * setup)
+{
+ void * r;
+ char * setup_byte;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+ setup_byte = (char*)setup;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* TODO: check for ongoing transmission */
+
+ /* Put USB setup data into corresponding FIFO */
+ HCD_WR4(r, MUSB_REG_FIFO0, HCD_8TO32(&setup_byte[0]));
+ HCD_WR4(r, MUSB_REG_FIFO0, HCD_8TO32(&setup_byte[sizeof(hcd_reg4)]));
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Send actual packet from FIFO */
+ HCD_SET(host_csr0, MUSB_VAL_HOST_CSR0_TXPKTRDY |
+ MUSB_VAL_HOST_CSR0_SETUPPKT);
+
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+}
+
+
+/*===========================================================================*
+ * musb_in_data_stage *
+ *===========================================================================*/
+void
+musb_in_data_stage(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Request IN DATA stage */
+ HCD_SET(host_csr0, MUSB_VAL_HOST_CSR0_REQPKT);
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+}
+
+
+/*===========================================================================*
+ * musb_out_data_stage *
+ *===========================================================================*/
+void
+musb_out_data_stage(void * cfg)
+{
+ DEBUG_DUMP;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* TODO: not needed for enumeration but will be needed later */
+ ((void)cfg);
+ USB_MSG("NOT IMPLEMENTED");
+}
+
+
+/*===========================================================================*
+ * musb_in_status_stage *
+ *===========================================================================*/
+void
+musb_in_status_stage(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Request IN STATUS stage */
+ HCD_SET(host_csr0, MUSB_VAL_HOST_CSR0_REQPKT |
+ MUSB_VAL_HOST_CSR0_STATUSPKT);
+
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+}
+
+
+/*===========================================================================*
+ * musb_out_status_stage *
+ *===========================================================================*/
+void
+musb_out_status_stage(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Request OUT STATUS stage */
+ HCD_SET(host_csr0, MUSB_VAL_HOST_CSR0_TXPKTRDY |
+ MUSB_VAL_HOST_CSR0_STATUSPKT);
+
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+}
+
+
+/*===========================================================================*
+ * musb_read_data *
+ *===========================================================================*/
+int
+musb_read_data(void * cfg, hcd_reg1 * buffer, int buffer_num)
+{
+ int count0;
+
+ DEBUG_DUMP;
+
+ /* Check if anything received at all */
+ if (EXIT_SUCCESS != musb_check_rxpktrdy(cfg)) {
+ USB_MSG("RXPKTRDY not set when receiving");
+ return HCD_READ_ERR;
+ }
+
+ /* Number of bytes received at EP0 */
+ count0 = musb_get_count(cfg);
+
+ /* Read from given FIFO */
+ if ((NULL != buffer) && (count0 > 0))
+ musb_read_fifo(cfg, buffer, count0, buffer_num);
+
+ /* Cleanup after reading */
+ musb_in_stage_cleanup(cfg);
+
+ return count0;
+}
+
+
+/*===========================================================================*
+ * musb_check_error *
+ *===========================================================================*/
+int
+musb_check_error(void * cfg)
+{
+ void * r;
+ hcd_reg2 host_csr0;
+
+ DEBUG_DUMP;
+
+ r = ((musb_core_config *)cfg)->regs;
+
+ /* Set EP and device address to be used in this command */
+ musb_set_state((musb_core_config *)cfg);
+
+ /* Get control status register for EP 0 */
+ host_csr0 = HCD_RD2(r, MUSB_REG_HOST_CSR0);
+
+ /* Check for common errors */
+ if (host_csr0 & MUSB_VAL_HOST_CSR0_ERROR) {
+ USB_MSG("HOST_CSR0 ERROR: %04X", host_csr0);
+ HCD_CLR(host_csr0, MUSB_VAL_HOST_CSR0_ERROR);
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+ return EXIT_FAILURE;
+ }
+
+ if (host_csr0 & MUSB_VAL_HOST_CSR0_RXSTALL) {
+ USB_MSG("HOST_CSR0 STALL: %04X", host_csr0);
+ HCD_CLR(host_csr0, MUSB_VAL_HOST_CSR0_RXSTALL);
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+ return EXIT_FAILURE;
+ }
+
+ if (host_csr0 & MUSB_VAL_HOST_CSR0_NAK_TIMEOUT) {
+ USB_MSG("HOST_CSR0 NAK_TIMEOUT: %04X", host_csr0);
+ HCD_CLR(host_csr0, MUSB_VAL_HOST_CSR0_NAK_TIMEOUT);
+ HCD_WR2(r, MUSB_REG_HOST_CSR0, host_csr0);
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
--- /dev/null
+/*
+ * Interface of low level MUSB core logic (variant independent)
+ */
+
+#ifndef _MUSB_CORE_H_
+#define _MUSB_CORE_H_
+
+#include <usb/hcd_common.h>
+
+
+/*===========================================================================*
+ * Types and constants *
+ *===========================================================================*/
+/* Structure to hold Mentor USB core configuration
+ * May be more than one on a single chip
+ * Should be initialized by MUSB's variant specific code (like AM335x) */
+typedef struct {
+
+ void * regs; /* Points to beginning of memory mapped registers */
+ hcd_reg1 ep; /* Currently used endpoint */
+ hcd_reg1 addr; /* Currently used address */
+}
+musb_core_config;
+
+
+/*===========================================================================*
+ * Function prototypes *
+ *===========================================================================*/
+/* Only to be used outside generic HCD code */
+void musb_core_start(void *);
+void musb_core_stop(void *);
+void musb_ep0_config(void *);
+
+
+/* For HCD interface */
+void musb_setup_device(void *, hcd_reg1, hcd_reg1);
+void musb_reset_device(void *);
+void musb_setup_stage(void *, hcd_ctrlrequest *);
+void musb_in_data_stage(void *);
+void musb_out_data_stage(void *);
+void musb_in_status_stage(void *);
+void musb_out_status_stage(void *);
+int musb_read_data(void *, hcd_reg1 *, int);
+int musb_check_error(void *);
+
+
+#endif /* !_MUSB_CORE_H_ */
--- /dev/null
+/*
+ * Common MUSB core registers definitions
+ */
+
+#ifndef _MUSB_REGS_H_
+#define _MUSB_REGS_H_
+
+#include <usb/hcd_common.h>
+
+
+/*===========================================================================*
+ * MUSB core register offsets *
+ *===========================================================================*/
+#define MUSB_REG_FADDR 0x00u
+#define MUSB_REG_POWER 0x01u
+#define MUSB_REG_INTRTX 0x02u
+#define MUSB_REG_INTRRX 0x04u
+#define MUSB_REG_INTRTXE 0x06u
+#define MUSB_REG_INTRRXE 0x08u
+#define MUSB_REG_INTRUSB 0x0Au
+#define MUSB_REG_INTRUSBE 0x0Bu
+#define MUSB_REG_FRAME 0x0Cu
+#define MUSB_REG_INDEX 0x0Eu
+#define MUSB_REG_TESTMODE 0x0Fu
+
+/* Proxy registers for endpoint configuration,
+ * that correspond to specific endpoint's register space
+ * selected with MUSB_REG_INDEX */
+#define MUSB_REG_TXMAXP 0x10u
+#define MUSB_REG_PERI_CSR0 0x12u
+#define MUSB_REG_HOST_CSR0 MUSB_REG_PERI_CSR0
+#define MUSB_REG_PERI_TXCSR MUSB_REG_PERI_CSR0
+#define MUSB_REG_HOST_TXCSR MUSB_REG_PERI_CSR0
+#define MUSB_REG_RXMAXP 0x14u
+#define MUSB_REG_PERI_RXCSR 0x16u
+#define MUSB_REG_HOST_RXCSR MUSB_PERI_RXCSR
+#define MUSB_REG_COUNT0 0x18u
+#define MUSB_REG_RXCOUNT MUSB_COUNT0
+#define MUSB_REG_HOST_TYPE0 0x1Au
+#define MUSB_REG_HOST_TXTYPE MUSB_HOST_TYPE0
+#define MUSB_REG_HOST_NAKLIMIT0 0x1Bu
+#define MUSB_REG_HOST_TXINTERVAL MUSB_HOST_NAKLIMIT0
+#define MUSB_REG_HOST_RXTYPE 0x1Cu
+#define MUSB_REG_HOST_RXINTERVAL 0x1Du
+#define MUSB_REG_CONFIGDATA 0x1Fu
+
+#define MUSB_REG_FIFO0 0x20u
+#define MUSB_REG_FIFO1 0x24u
+#define MUSB_REG_FIFO2 0x28u
+#define MUSB_REG_FIFO3 0x2Cu
+#define MUSB_REG_FIFO4 0x30u
+#define MUSB_REG_FIFO_LEN 0x04u
+
+#define MUSB_REG_DEVCTL 0x60u
+#define MUSB_REG_TXFIFOSZ 0x62u
+#define MUSB_REG_RXFIFOSZ 0x63u
+#define MUSB_REG_TXFIFOADDR 0x64u
+#define MUSB_REG_RXFIFOADDR 0x66u
+
+#define MUSB_REG_TXFUNCADDR 0x80u
+#define MUSB_REG_TXHUBADDR 0x82u
+#define MUSB_REG_TXHUBPORT 0x83u
+#define MUSB_REG_RXFUNCADDR 0x84u
+#define MUSB_REG_RXHUBADDR 0x86u
+#define MUSB_REG_RXHUBPORT 0x87u
+
+
+/*===========================================================================*
+ * MUSB core register values *
+ *===========================================================================*/
+/* POWER */
+#define MUSB_VAL_POWER_ENSUSPM HCD_BIT(0)
+#define MUSB_VAL_POWER_SUSPENDM HCD_BIT(1)
+#define MUSB_VAL_POWER_RESUME HCD_BIT(2)
+#define MUSB_VAL_POWER_RESET HCD_BIT(3)
+#define MUSB_VAL_POWER_HSMODE HCD_BIT(4)
+#define MUSB_VAL_POWER_HSEN HCD_BIT(5)
+#define MUSB_VAL_POWER_SOFTCONN HCD_BIT(6)
+#define MUSB_VAL_POWER_ISOUPDATE HCD_BIT(7)
+
+/* DEVCTL */
+#define MUSB_VAL_DEVCTL_SESSION HCD_BIT(0)
+#define MUSB_VAL_DEVCTL_HOSTREQ HCD_BIT(1)
+#define MUSB_VAL_DEVCTL_HOSTMODE HCD_BIT(2)
+#define MUSB_VAL_DEVCTL_VBUS_1 HCD_BIT(3)
+#define MUSB_VAL_DEVCTL_VBUS_2 HCD_BIT(4)
+#define MUSB_VAL_DEVCTL_VBUS_3 (HCD_BIT(3) | HCD_BIT(4))
+#define MUSB_VAL_DEVCTL_LSDEV HCD_BIT(5)
+#define MUSB_VAL_DEVCTL_FSDEV HCD_BIT(6)
+#define MUSB_VAL_DEVCTL_BDEVICE HCD_BIT(7)
+
+/* INTRUSBE */
+#define MUSB_VAL_INTRUSBE_SUSPEND HCD_BIT(0)
+#define MUSB_VAL_INTRUSBE_RESUME HCD_BIT(1)
+#define MUSB_VAL_INTRUSBE_RESET_BABBLE HCD_BIT(2)
+#define MUSB_VAL_INTRUSBE_SOF HCD_BIT(3)
+#define MUSB_VAL_INTRUSBE_CONN HCD_BIT(4)
+#define MUSB_VAL_INTRUSBE_DISCON HCD_BIT(5)
+#define MUSB_VAL_INTRUSBE_SESSREQ HCD_BIT(6)
+#define MUSB_VAL_INTRUSBE_VBUSERR HCD_BIT(7)
+
+/* HOST_TYPE0 */
+#define MUSB_VAL_HOST_TYPE0_MASK (HCD_BIT(6) | HCD_BIT(7))
+#define MUSB_VAL_HOST_TYPE0_HIGH_SPEED HCD_BIT(6)
+#define MUSB_VAL_HOST_TYPE0_FULL_SPEED HCD_BIT(7)
+#define MUSB_VAL_HOST_TYPE0_LOW_SPEED (HCD_BIT(6) | HCD_BIT(7))
+
+/* INTRTXE */
+#define MUSB_VAL_INTRTXE_EP0 HCD_BIT(0)
+#define MUSB_VAL_INTRTXE_EP1TX HCD_BIT(1)
+#define MUSB_VAL_INTRTXE_EP2TX HCD_BIT(2)
+#define MUSB_VAL_INTRTXE_EP3TX HCD_BIT(3)
+#define MUSB_VAL_INTRTXE_EP4TX HCD_BIT(4)
+
+/* HOST_CSR0 */
+#define MUSB_VAL_HOST_CSR0_RXPKTRDY HCD_BIT(0)
+#define MUSB_VAL_HOST_CSR0_TXPKTRDY HCD_BIT(1)
+#define MUSB_VAL_HOST_CSR0_RXSTALL HCD_BIT(2)
+#define MUSB_VAL_HOST_CSR0_SETUPPKT HCD_BIT(3)
+#define MUSB_VAL_HOST_CSR0_ERROR HCD_BIT(4)
+#define MUSB_VAL_HOST_CSR0_REQPKT HCD_BIT(5)
+#define MUSB_VAL_HOST_CSR0_STATUSPKT HCD_BIT(6)
+#define MUSB_VAL_HOST_CSR0_NAK_TIMEOUT HCD_BIT(7)
+#define MUSB_VAL_HOST_CSR0_FLUSHFIFO HCD_BIT(8)
+
+#endif /* !_MUSB_REGS_H_ */
--- /dev/null
+/*
+ * Contains commonly used types and procedures, for HCD handling/initialization
+ * If possible, everything OS specific (IPC, virtual memory...) should be here
+ */
+
+#ifndef _HCD_COMMON_H_
+#define _HCD_COMMON_H_
+
+#include <ddekit/thread.h>
+#include <ddekit/semaphore.h>
+#include <ddekit/usb.h>
+
+#include <minix/usb.h> /* for setup structures */
+#include <minix/usb_ch9.h> /* for descriptor structures */
+
+
+/*===========================================================================*
+ * USB register handling defines *
+ *===========================================================================*/
+/* Helper type used for register bitwise access */
+#define HCD_BIT(num) (0x01u << (num))
+
+/* Unsigned type that can hold all possible addresses */
+typedef unsigned long hcd_addr;
+
+/* Register types */
+typedef unsigned long hcd_reg4;
+typedef unsigned short hcd_reg2;
+typedef unsigned char hcd_reg1;
+
+/* For register dereferencing */
+#define _HCD_REG4 hcd_reg4 * volatile
+#define _HCD_REG2 hcd_reg2 * volatile
+#define _HCD_REG1 hcd_reg1 * volatile
+
+/* Scalar address to dereference */
+#define _HCD_ADDR(base, off) (((hcd_addr)(base))+(off))
+
+/* Defines for fixed size register access
+ * May cause unaligned memory access */
+#define HCD_WR4(base, off, val) (*((_HCD_REG4)_HCD_ADDR(base, off)) = (val))
+#define HCD_WR2(base, off, val) (*((_HCD_REG2)_HCD_ADDR(base, off)) = (val))
+#define HCD_WR1(base, off, val) (*((_HCD_REG1)_HCD_ADDR(base, off)) = (val))
+#define HCD_RD4(base, off) (*((_HCD_REG4)_HCD_ADDR(base, off)))
+#define HCD_RD2(base, off) (*((_HCD_REG2)_HCD_ADDR(base, off)))
+#define HCD_RD1(base, off) (*((_HCD_REG1)_HCD_ADDR(base, off)))
+
+/* Other useful defines */
+#define HCD_SET(val, bits) ((val)|=(bits))
+#define HCD_CLR(val, bits) ((val)&=~(bits))
+
+/* Alignment safe conversion from 'bytes' array to a word */
+#define HCD_8TO32(bytes) (((bytes)[0]) | \
+ (((bytes)[1])<<8) | \
+ (((bytes)[2])<<16) | \
+ (((bytes)[3])<<24))
+
+/* Convert type's 'sizeof' to 4-byte words count */
+#define HCD_SIZEOF_TO_4(type) ((sizeof(type)+3)/4)
+
+
+/*===========================================================================*
+ * USB descriptor types *
+ *===========================================================================*/
+typedef struct usb_ctrlrequest hcd_ctrlrequest;
+typedef usb_descriptor_t hcd_descriptor;
+typedef usb_device_descriptor_t hcd_device_descriptor;
+typedef usb_config_descriptor_t hcd_config_descriptor;
+typedef usb_interface_descriptor_t hcd_interface_descriptor;
+typedef usb_endpoint_descriptor_t hcd_endpoint_descriptor;
+typedef usb_string_descriptor_t hcd_string_descriptor;
+
+
+/*===========================================================================*
+ * HCD descriptor tree types *
+ *===========================================================================*/
+typedef struct hcd_endpoint {
+
+ hcd_endpoint_descriptor descriptor;
+}
+hcd_endpoint;
+
+typedef struct hcd_interface {
+
+ hcd_interface_descriptor descriptor;
+ hcd_endpoint * endpoint;
+ int num_endpoints;
+}
+hcd_interface;
+
+typedef struct hcd_configuration {
+
+ hcd_config_descriptor descriptor;
+ hcd_interface * interface;
+ int num_interfaces;
+}
+hcd_configuration;
+
+
+/*===========================================================================*
+ * HCD device helper types *
+ *===========================================================================*/
+typedef void (*hcd_thread_function)(void *);
+typedef ddekit_thread_t hcd_thread;
+typedef ddekit_sem_t hcd_lock;
+typedef struct hcd_driver_state hcd_driver_state;
+typedef struct ddekit_usb_urb hcd_urb;
+
+typedef enum {
+
+ HCD_STATE_DISCONNECTED = 0, /* default for initialization */
+ HCD_STATE_CONNECTION_PENDING,
+ HCD_STATE_CONNECTED
+}
+hcd_state;
+
+/* Largest value that can be transfered by this driver at a time
+ * see MAXPAYLOAD in TXMAXP/RXMAXP */
+#define MAX_WTOTALLENGTH 1024
+
+typedef struct hcd_device_state {
+
+ hcd_driver_state * driver;
+ hcd_thread * thread;
+ hcd_lock * lock;
+ hcd_urb * urb;
+ void * data;
+
+ hcd_device_descriptor device_desc;
+ hcd_configuration config_tree;
+ hcd_reg1 max_packet_size;
+
+ hcd_state state;
+
+ /* Number of bytes received/transmitted in last transfer */
+ int data_len;
+ /* TODO: forcefully align buffer to make things clear? */
+ /* Buffer for each device to hold transfered data */
+ hcd_reg1 buffer[MAX_WTOTALLENGTH];
+}
+hcd_device_state;
+
+
+/*===========================================================================*
+ * Other definitions *
+ *===========================================================================*/
+#define HCD_NANOSLEEP_SEC(sec) ((sec) * 1000000000)
+#define HCD_NANOSLEEP_MSEC(msec) ((msec) * 1000000)
+#define HCD_NANOSLEEP_USEC(usec) ((usec) * 1000)
+
+/* Default USB communication parameters */
+#define HCD_DEFAULT_EP 0x00
+#define HCD_DEFAULT_ADDR 0x00
+
+/* TODO: one device */
+#define HCD_ATTACHED_ADDR 0x01
+
+
+/*===========================================================================*
+ * Operating system specific *
+ *===========================================================================*/
+/* Generic method for registering interrupts */
+int hcd_os_interrupt_attach(int irq, void (*init)(void *),
+ void (*isr)(void *), void *priv);
+
+/* Generic method for unregistering interrupts */
+void hcd_os_interrupt_detach(int);
+
+/* Generic method for enabling interrupts */
+void hcd_os_interrupt_enable(int);
+
+/* Generic method for disabling interrupts */
+void hcd_os_interrupt_disable(int);
+
+/* Returns pointer to memory mapped for given arguments */
+void * hcd_os_regs_init(unsigned long, unsigned long);
+
+/* Unregisters mapped memory */
+int hcd_os_regs_deinit(unsigned long, unsigned long);
+
+/* Configure clocking */
+int hcd_os_clkconf(unsigned long, unsigned long, unsigned long);
+
+/* Release clocking */
+int hcd_os_clkconf_release(void);
+
+
+/*===========================================================================*
+ * Device handling calls *
+ *===========================================================================*/
+/* Initializes device threading on connection */
+int hcd_connect_device(hcd_device_state *, hcd_thread_function);
+
+/* Cleans after device disconnection */
+void hcd_disconnect_device(hcd_device_state *);
+
+/* Locks device thread until 'hcd_device_continue' */
+void hcd_device_wait(hcd_device_state *);
+
+/* Unlocks device thread halted by 'hcd_device_wait' */
+void hcd_device_continue(hcd_device_state *);
+
+
+/*===========================================================================*
+ * Descriptor tree calls *
+ *===========================================================================*/
+/* Creates descriptor tree based on given buffer */
+int hcd_buffer_to_tree(hcd_reg1 *, int, hcd_configuration *);
+
+/* Frees descriptor tree */
+void hcd_tree_cleanup(hcd_configuration *);
+
+
+#endif /* !_HCD_COMMON_H_ */
--- /dev/null
+/*
+ * Whatever must be known to DDEkit callers
+ */
+
+#ifndef _HCD_DDEKIT_H_
+#define _HCD_DDEKIT_H_
+
+#include <usb/hcd_common.h>
+
+/*===========================================================================*
+ * External declarations *
+ *===========================================================================*/
+void hcd_connect_cb(hcd_device_state *);
+void hcd_disconnect_cb(hcd_device_state *);
+void hcd_completion_cb(void *);
+
+
+#endif /* !_HCD_DDEKIT_H_ */
--- /dev/null
+/*
+ * Interface for HCD
+ *
+ * This file holds prototypes that must be implemented by HCD
+ * and event call that should be called when interrupt occurred
+ */
+
+#ifndef _HCD_INTERFACE_H_
+#define _HCD_INTERFACE_H_
+
+#include <usb/hcd_common.h>
+
+
+/*===========================================================================*
+ * HCD event handling types *
+ *===========================================================================*/
+/* Possible HCD events */
+typedef enum {
+
+ HCD_EVENT_CONNECTED,
+ HCD_EVENT_DISCONNECTED,
+ HCD_EVENT_ENDPOINT
+}
+hcd_event;
+
+/* Possible HCD sub-events */
+typedef enum {
+
+ HCD_SUBEVENT_NONE,
+ HCD_SUBEVENT_EP0,
+}
+hcd_subevent;
+
+
+/*===========================================================================*
+ * HCD additional defines *
+ *===========================================================================*/
+#define HCD_READ_ERR -1
+
+
+/*===========================================================================*
+ * HCD driver structure to be filled
+ *===========================================================================*/
+struct hcd_driver_state {
+ /* Standard USB controller procedures */
+ void (*setup_device) (void *, hcd_reg1, hcd_reg1);
+ void (*reset_device) (void *);
+ void (*setup_stage) (void *, hcd_ctrlrequest *);
+ void (*in_data_stage) (void *);
+ void (*out_data_stage) (void *);
+ void (*in_status_stage) (void *);
+ void (*out_status_stage) (void *);
+ int (*read_data) (void *, hcd_reg1 *, int);
+ int (*check_error) (void *);
+
+ /* Controller's private data (like mapped registers) */
+ void * private_data;
+
+ /* Current state to be handled by driver */
+ hcd_event event;
+ hcd_subevent subevent;
+};
+
+
+/*===========================================================================*
+ * HCD event handling routine *
+ *===========================================================================*/
+/* Handle asynchronous event
+ * This must be called in case of specific HCD interrupts listed above */
+void hcd_handle_event(hcd_driver_state *);
+
+
+#endif /* !_HCD_INTERFACE_H_ */
--- /dev/null
+/*
+ * Externally visible interface for possible USB controllers
+ */
+
+#ifndef _HCD_PLATFORMS_H_
+#define _HCD_PLATFORMS_H_
+
+
+/*===========================================================================*
+ * MUSB *
+ *===========================================================================*/
+/* ----- AM335X ----- */
+int musb_am335x_init(void);
+void musb_am335x_deinit(void);
+/* ----- AM/DM37X ----- */
+int musb_dm37x_init(void);
+void musb_dm37x_deinit(void);
+
+
+#endif /* !_HCD_PLATFORMS_H_ */
--- /dev/null
+/*
+ * Whatever is commonly used throughout USB code
+ */
+
+#ifndef _USB_COMMON_H_
+#define _USB_COMMON_H_
+
+/* For commonly used: NULL, EXIT_*, and stuff like that */
+#include <stdlib.h>
+
+/* Current printf implementation for dumping important messages */
+#include <stdio.h>
+
+#if 1
+/* TODO: should be elsewhere */
+#define DEBUG
+#endif
+
+
+/*===========================================================================*
+ * Standard output message *
+ *===========================================================================*/
+#define USB_MSG(fmt, ...) \
+ do { \
+ printf("USBD: "); \
+ printf(fmt, ##__VA_ARGS__); \
+ printf("\n"); \
+ } while(0)
+
+
+/*===========================================================================*
+ * Debug helpers *
+ *===========================================================================*/
+#ifdef DEBUG
+#define DEBUG_DUMP \
+ do { \
+ printf("USBD (DEBUG %s)\n", __func__); \
+ } while(0)
+
+#define USB_DBG(fmt, ...) \
+ do { \
+ printf("USBD (DEBUG %s): ", __func__); \
+ printf(fmt, ##__VA_ARGS__); \
+ printf("\n"); \
+ } while(0)
+
+#else
+#define DEBUG_DUMP
+#define USB_DBG(fmt, ...)
+#endif
+
+
+/*===========================================================================*
+ * Assert for USB code *
+ *===========================================================================*/
+#define USB_ASSERT(cond, otherwise) \
+ do { \
+ if(!(cond)) { \
+ USB_MSG("ERROR - "otherwise); \
+ exit(EXIT_FAILURE); \
+ } \
+ } while(0)
+
+
+#endif /* !_USB_COMMON_H_ */
--- /dev/null
+/*
+ * Interface for USBD
+ *
+ * This file holds prototypes that must be implemented by platform
+ * specific USBD
+ *
+ * Must be implemented once per USBD but may be used for multiple
+ * controllers at a time when platform has more than one HCD
+ */
+
+#ifndef _USBD_INTERFACE_H_
+#define _USBD_INTERFACE_H_
+
+/*===========================================================================*
+ * Prototypes to be implemented *
+ *===========================================================================*/
+/* Must set up HCDs in general and interrupts to
+ * be handled by DDEkit in particular */
+int usbd_init_hcd(void);
+
+/* Should clean whatever usbd_init_hcd used */
+void usbd_deinit_hcd(void);
+
+#endif /* !_USBD_INTERFACE_H_ */
--- /dev/null
+service usbd
+{
+ system
+ PRIVCTL
+ UMAP
+ IRQCTL
+ ;
+ irq
+ 92 #BeagleXM
+ 17 #BeagleBoneWhite
+ 18 #BeagleBoneWhite
+ 19 #BeagleBoneWhite
+ ;
+};