Esempio n. 1
0
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);
}
Esempio n. 2
0
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;
}
Esempio n. 4
0
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);
	}
Esempio n. 5
0
/*------------------------------------------------------------------------*
 *	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);
}
Esempio n. 7
0
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);
	}
}
Esempio n. 8
0
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;
}
Esempio n. 9
0
void
cam_simq_free(struct cam_devq *devq)
{
	BSD_ASSERT(devq == BSD_CAM_DEVQ_DUMMY);
}