int usbstrg_exportluns(FAR void *handle) { FAR struct usbstrg_alloc_s *alloc = (FAR struct usbstrg_alloc_s *)handle; FAR struct usbstrg_dev_s *priv; FAR struct usbstrg_driver_s *drvr; irqstate_t flags; #ifdef SDCC pthread_attr_t attr; #endif int ret; #ifdef CONFIG_DEBUG if (!alloc) { usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EXPORTLUNSINVALIDARGS), 0); return -ENXIO; } #endif priv = &alloc->dev; drvr = &alloc->drvr; /* Start the worker thread */ pthread_mutex_lock(&priv->mutex); priv->thstate = USBSTRG_STATE_NOTSTARTED; priv->theventset = USBSTRG_EVENT_NOEVENTS; #ifdef SDCC (void)pthread_attr_init(&attr); ret = pthread_create(&priv->thread, &attr, usbstrg_workerthread, (pthread_addr_t)priv); #else ret = pthread_create(&priv->thread, NULL, usbstrg_workerthread, (pthread_addr_t)priv); #endif if (ret != OK) { usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_THREADCREATE), (uint16_t)-ret); goto errout_with_mutex; } /* Register the USB storage class driver */ ret = usbdev_register(&drvr->drvr); if (ret != OK) { usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_DEVREGISTER), (uint16_t)-ret); goto errout_with_mutex; } /* Signal to start the thread */ flags = irqsave(); priv->theventset |= USBSTRG_EVENT_READY; pthread_cond_signal(&priv->cond); irqrestore(flags); errout_with_mutex: pthread_mutex_unlock(&priv->mutex); return ret; }
int usbdev_apbinitialize(struct apbridge_usb_driver *driver) { struct apbridge_alloc_s *alloc; struct apbridge_dev_s *priv; struct apbridge_driver_s *drvr; int ret; /* Allocate the structures needed */ alloc = (struct apbridge_alloc_s *) kmm_malloc(sizeof(struct apbridge_alloc_s)); if (!alloc) { usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALLOCDEVSTRUCT), 0); return -ENOMEM; } /* Convenience pointers into the allocated blob */ priv = &alloc->dev; drvr = &alloc->drvr; /* Initialize the USB driver structure */ memset(priv, 0, sizeof(struct apbridge_dev_s)); priv->driver = driver; /* Initialize the USB class driver structure */ drvr->drvr.speed = USB_SPEED_HIGH; drvr->drvr.ops = &g_driverops; drvr->dev = priv; /* Register the USB serial class driver */ ret = usbdev_register(&drvr->drvr); if (ret) { usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_DEVREGISTER), (uint16_t) - ret); goto errout_with_alloc; } ret = priv->driver->init(priv); if (ret) goto errout_with_init; /* Register the single port supported by this implementation */ return OK; errout_with_init: usbdev_unregister(&drvr->drvr); errout_with_alloc: kmm_free(alloc); return ret; }
FAR void *composite_initialize(void) { FAR struct composite_alloc_s *alloc; FAR struct composite_dev_s *priv; FAR struct composite_driver_s *drvr; int ret; /* Allocate the structures needed */ alloc = (FAR struct composite_alloc_s *)kmm_malloc(sizeof(struct composite_alloc_s)); if (!alloc) { usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_ALLOCDEVSTRUCT), 0); return NULL; } /* Convenience pointers into the allocated blob */ priv = &alloc->dev; drvr = &alloc->drvr; /* Initialize the USB composite driver structure */ memset(priv, 0, sizeof(struct composite_dev_s)); /* Get the constitueat class driver objects */ ret = DEV1_CLASSOBJECT(&priv->dev1); if (ret < 0) { usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_CLASSOBJECT), (uint16_t)-ret); goto errout_with_alloc; } ret = DEV2_CLASSOBJECT(&priv->dev2); if (ret < 0) { usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_CLASSOBJECT), (uint16_t)-ret); goto errout_with_alloc; } /* Initialize the USB class driver structure */ #ifdef CONFIG_USBDEV_DUALSPEED drvr->drvr.speed = USB_SPEED_HIGH; #else drvr->drvr.speed = USB_SPEED_FULL; #endif drvr->drvr.ops = &g_driverops; drvr->dev = priv; /* Register the USB composite class driver */ ret = usbdev_register(&drvr->drvr); if (ret) { usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_DEVREGISTER), (uint16_t)-ret); goto errout_with_alloc; } return (FAR void *)alloc; errout_with_alloc: kmm_free(alloc); return NULL; }
static #endif int usbmsc_exportluns(FAR void *handle) { FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle; FAR struct usbmsc_dev_s *priv; #ifndef CONFIG_USBMSC_COMPOSITE FAR struct usbmsc_driver_s *drvr; #endif irqstate_t flags; int ret = OK; #ifdef CONFIG_DEBUG if (!alloc) { usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EXPORTLUNSINVALIDARGS), 0); return -ENXIO; } #endif priv = &alloc->dev; #ifndef CONFIG_USBMSC_COMPOSITE drvr = &alloc->drvr; #endif /* Start the worker thread * * REVISIT: g_usbmsc_handoff is a global and, hence, really requires * some protection against re-entrant usage. */ usbmsc_scsi_lock(priv); priv->thstate = USBMSC_STATE_NOTSTARTED; priv->theventset = USBMSC_EVENT_NOEVENTS; g_usbmsc_handoff = priv; uvdbg("Starting SCSI worker thread\n"); priv->thpid = kernel_thread("scsid", CONFIG_USBMSC_SCSI_PRIO, CONFIG_USBMSC_SCSI_STACKSIZE, usbmsc_scsi_main, NULL); if (priv->thpid <= 0) { usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_THREADCREATE), (uint16_t)errno); goto errout_with_lock; } /* Wait for the worker thread to run and initialize */ uvdbg("Waiting for the SCSI worker thread\n"); usbmsc_sync_wait(priv); DEBUGASSERT(g_usbmsc_handoff == NULL); /* Register the USB storage class driver (unless we are part of a composite device) */ #ifndef CONFIG_USBMSC_COMPOSITE ret = usbdev_register(&drvr->drvr); if (ret != OK) { usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEVREGISTER), (uint16_t)-ret); goto errout_with_lock; } #endif /* Signal to start the thread */ uvdbg("Signalling for the SCSI worker thread\n"); flags = irqsave(); priv->theventset |= USBMSC_EVENT_READY; usbmsc_scsi_signal(priv); irqrestore(flags); errout_with_lock: usbmsc_scsi_unlock(priv); return ret; }