static void
rtems_bsd_ccb_callback(struct cam_periph *periph, union ccb *ccb)
{
struct cam_sim *sim = ccb->ccb_h.sim;
BSD_ASSERT(periph == NULL && sim->state == BSD_SIM_INIT_BUSY);
rtems_bsd_sim_set_state_and_notify(sim, BSD_SIM_INIT_READY);
}
static int
nexus_probe(device_t dev)
{
rtems_status_code status;
int err;
size_t i;
device_set_desc(dev, "RTEMS Nexus device");
status = rtems_interrupt_server_initialize(
BSD_TASK_PRIORITY_INTERRUPT,
BSD_MINIMUM_TASK_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
NULL
);
BSD_ASSERT(status == RTEMS_SUCCESSFUL);
mem_rman.rm_start = 0;
mem_rman.rm_end = ~0UL;
mem_rman.rm_type = RMAN_ARRAY;
mem_rman.rm_descr = "I/O memory addresses";
err = rman_init(&mem_rman) != 0;
BSD_ASSERT(err == 0);
err = rman_manage_region(&mem_rman, mem_rman.rm_start, mem_rman.rm_end);
BSD_ASSERT(err == 0);
irq_rman.rm_start = 0;
irq_rman.rm_end = ~0UL;
irq_rman.rm_type = RMAN_ARRAY;
irq_rman.rm_descr = "Interrupt vectors";
err = rman_init(&irq_rman) != 0;
BSD_ASSERT(err == 0);
err = rman_manage_region(&irq_rman, irq_rman.rm_start, irq_rman.rm_end);
BSD_ASSERT(err == 0);
for (i = 0; i < rtems_bsd_nexus_device_count; ++i) {
const rtems_bsd_device *nd = &rtems_bsd_nexus_devices[i];
device_add_child(dev, nd->name, nd->unit);
}
return (0);
}
static void
rtems_bsd_page_init(void *arg)
{
rtems_status_code sc;
void *area;
void **obj_table;
rtems_rbheap_chunk *chunks;
size_t i;
size_t n;
uintptr_t heap_size;
mtx_init(&page_heap_mtx, "page heap", NULL, MTX_DEF);
heap_size = rtems_bsd_get_allocator_domain_size(
RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE);
area = rtems_heap_allocate_aligned_with_boundary(heap_size, PAGE_SIZE,
0);
BSD_ASSERT(area != NULL);
sc = rtems_rbheap_initialize(&page_heap, area, heap_size, PAGE_SIZE,
rtems_rbheap_extend_descriptors_with_malloc, NULL);
BSD_ASSERT(sc == RTEMS_SUCCESSFUL);
rtems_rbheap_set_extend_descriptors(&page_heap,
rtems_rbheap_extend_descriptors_never);
n = heap_size / PAGE_SIZE;
chunks = malloc(n * sizeof(*chunks), M_RTEMS_HEAP, M_NOWAIT);
BSD_ASSERT(chunks != NULL);
for (i = 0; i < n; ++i) {
rtems_rbheap_add_to_spare_descriptor_chain(&page_heap,
&chunks[i]);
}
obj_table = calloc(n, sizeof(*obj_table));
rtems_bsd_page_area_begin = (uintptr_t)area;
rtems_bsd_page_object_table = obj_table;
}
static int
nexus_probe(device_t dev)
{
static const char name[] = "IRQS";
rtems_status_code status;
int err;
const rtems_bsd_device *nd;
device_set_desc(dev, "RTEMS Nexus device");
#ifndef DISABLE_INTERRUPT_EXTENSION
status = rtems_interrupt_server_initialize(
rtems_bsd_get_task_priority(name),
rtems_bsd_get_task_stack_size(name),
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
NULL
);
BSD_ASSERT(status == RTEMS_SUCCESSFUL);
#endif
mem_rman.rm_start = 0;
mem_rman.rm_end = ~0UL;
mem_rman.rm_type = RMAN_ARRAY;
mem_rman.rm_descr = "I/O memory addresses";
err = rman_init(&mem_rman) != 0;
BSD_ASSERT(err == 0);
err = rman_manage_region(&mem_rman, mem_rman.rm_start, mem_rman.rm_end);
BSD_ASSERT(err == 0);
irq_rman.rm_start = 0;
irq_rman.rm_end = ~0UL;
irq_rman.rm_type = RMAN_ARRAY;
irq_rman.rm_descr = "Interrupt vectors";
err = rman_init(&irq_rman) != 0;
BSD_ASSERT(err == 0);
err = rman_manage_region(&irq_rman, irq_rman.rm_start, irq_rman.rm_end);
BSD_ASSERT(err == 0);
SET_FOREACH(nd, nexus) {
device_add_child(dev, nd->name, nd->unit);
}
/*------------------------------------------------------------------------*
* usb_proc_drain
*
* This function will tear down an USB process, waiting for the
* currently executing command to return.
*
* NOTE: If the structure pointed to by "up" is all zero,
* this function does nothing.
*------------------------------------------------------------------------*/
void
usb_proc_drain(struct usb_process *up)
{
/* check if not initialised */
if (up->up_mtx == NULL)
return;
/* handle special case with Giant */
if (up->up_mtx != &Giant)
mtx_assert(up->up_mtx, MA_NOTOWNED);
mtx_lock(up->up_mtx);
/* Set the gone flag */
up->up_gone = 1;
while (up->up_ptr) {
/* Check if we need to wakeup the USB process */
if (up->up_msleep || up->up_csleep) {
up->up_msleep = 0;
up->up_csleep = 0;
cv_signal(&up->up_cv);
}
/* Check if we are still cold booted */
if (cold) {
#ifndef __rtems__
USB_THREAD_SUSPEND(up->up_ptr);
printf("WARNING: A USB process has "
"been left suspended\n");
break;
#else /* __rtems__ */
BSD_ASSERT(0);
#endif /* __rtems__ */
}
cv_wait(&up->up_cv, up->up_mtx);
}
/* Check if someone is waiting - should not happen */
if (up->up_dsleep) {
up->up_dsleep = 0;
cv_broadcast(&up->up_drain);
DPRINTF("WARNING: Someone is waiting "
"for USB process drain!\n");
}
mtx_unlock(up->up_mtx);
}
static void
irqs_sysinit(void)
{
static const char name[] = "IRQS";
rtems_status_code status;
status = rtems_interrupt_server_initialize(
rtems_bsd_get_task_priority(name),
rtems_bsd_get_task_stack_size(name),
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
NULL
);
BSD_ASSERT(status == RTEMS_SUCCESSFUL);
}
static void
rtems_bsd_csio_callback(struct cam_periph *periph, union ccb *ccb)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool done = false;
struct cam_sim *sim = ccb->ccb_h.sim;
BSD_ASSERT(periph == NULL && sim->state == BSD_SIM_BUSY);
if (ccb->ccb_h.status == CAM_REQ_CMP) {
rtems_blkdev_sg_buffer *sg = ccb->csio.sg_current;
if (sg != ccb->csio.sg_end) {
scsi_read_write(
&ccb->csio,
BSD_SCSI_RETRIES,
rtems_bsd_csio_callback,
BSD_SCSI_TAG,
ccb->csio.readop,
0,
BSD_SCSI_MIN_COMMAND_SIZE,
sg->block,
sg->length / 512, /* FIXME */
sg->buffer,
sg->length,
SSD_FULL_SIZE,
BSD_SCSI_TIMEOUT
);
ccb->csio.sg_current = sg + 1;
(*sim->sim_action)(sim, ccb);
} else {
done = true;
}
} else if (ccb->ccb_h.status == CAM_SEL_TIMEOUT) {
sc = RTEMS_UNSATISFIED;
done = true;
} else {
sc = RTEMS_IO_ERROR;
done = true;
}
if (done) {
ccb->csio.req->req_done(ccb->csio.req->done_arg, sc);
rtems_bsd_sim_set_state_and_notify(sim, BSD_SIM_IDLE);
}
}
static rtems_status_code
rtems_bsd_ccb_action(union ccb *ccb)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
struct cam_sim *sim = ccb->ccb_h.sim;
mtx_lock(sim->mtx);
BSD_ASSERT(sim->state == BSD_SIM_INIT);
rtems_bsd_sim_set_state(sim, BSD_SIM_INIT_BUSY);
(*sim->sim_action)(sim, ccb);
rtems_bsd_sim_wait_for_state(sim, BSD_SIM_INIT_READY);
if (ccb->ccb_h.status != CAM_REQ_CMP) {
sc = RTEMS_IO_ERROR;
}
rtems_bsd_sim_set_state(sim, BSD_SIM_INIT);
mtx_unlock(sim->mtx);
return sc;
}
void
cam_simq_free(struct cam_devq *devq)
{
BSD_ASSERT(devq == BSD_CAM_DEVQ_DUMMY);
}
