static void
pvscsi_init_rings(void *iobase, struct pvscsi_ring_dsc_s **ring_dsc)
{
struct PVSCSICmdDescSetupRings cmd = {0,};
struct pvscsi_ring_dsc_s *dsc = memalign_high(PAGE_SIZE, sizeof(*dsc));
if (!dsc) {
warn_noalloc();
return;
}
dsc->ring_state =
(struct PVSCSIRingsState *)memalign_high(PAGE_SIZE, PAGE_SIZE);
dsc->ring_reqs =
(struct PVSCSIRingReqDesc *)memalign_high(PAGE_SIZE, PAGE_SIZE);
dsc->ring_cmps =
(struct PVSCSIRingCmpDesc *)memalign_high(PAGE_SIZE, PAGE_SIZE);
if (!dsc->ring_state || !dsc->ring_reqs || !dsc->ring_cmps) {
warn_noalloc();
return;
}
memset(dsc->ring_state, 0, PAGE_SIZE);
memset(dsc->ring_reqs, 0, PAGE_SIZE);
memset(dsc->ring_cmps, 0, PAGE_SIZE);
cmd.reqRingNumPages = 1;
cmd.cmpRingNumPages = 1;
cmd.ringsStatePPN = virt_to_phys(dsc->ring_state) >> PAGE_SHIFT;
cmd.reqRingPPNs[0] = virt_to_phys(dsc->ring_reqs) >> PAGE_SHIFT;
cmd.cmpRingPPNs[0] = virt_to_phys(dsc->ring_cmps) >> PAGE_SHIFT;
pvscsi_write_cmd_desc(iobase, PVSCSI_CMD_SETUP_RINGS,
&cmd, sizeof(cmd));
*ring_dsc = dsc;
}
struct shared_info *get_shared_info(void)
{
static struct shared_info *shared_info = NULL;
struct xen_add_to_physmap xatp;
if (shared_info != NULL)
return shared_info;
xatp.domid = DOMID_SELF;
xatp.space = XENMAPSPACE_shared_info;
xatp.idx = 0;
shared_info = memalign_high(PAGE_SIZE, PAGE_SIZE);
memset(shared_info, 0, PAGE_SIZE);
xatp.gpfn = ((unsigned long)shared_info >> PAGE_SHIFT);
dprintf(1, "allocated shared info %d bytes at %p, gpfn 0x%lx\n",sizeof(*shared_info), shared_info, xatp.gpfn);
//xatp.gpfn = malloc_high(sizeof(shared_info));
//shared_info = (struct shared_info *)(xatp.gpfn << PAGE_SHIFT);
if (hypercall_memory_op(XENMEM_add_to_physmap, &xatp) != 0)
panic("MAP info page fail");
dprintf(1, "time is %d\n", shared_info->wc_sec);
dprintf(1, "evtchn_pending[0] 0x%08lx\n", shared_info->evtchn_pending[0]);
dprintf(1, "evtchn_mask[0] 0x%08lx\n", shared_info->evtchn_mask[0]);
dprintf(1, "VCPU0 evtchn_upcall_pending 0x%x\n", shared_info->vcpu_info[0].evtchn_upcall_pending);
dprintf(1, "VCPU0 evtchn_upcall_mask 0x%x\n", shared_info->vcpu_info[0].evtchn_upcall_mask);
dprintf(1, "VCPU0 evtchn_pending_sel 0x%08lx\n", shared_info->vcpu_info[0].evtchn_pending_sel);
return shared_info;
}
void
ohci_init(void *data)
{
if (! CONFIG_USB_OHCI)
return;
struct usb_s *cntl = data;
// XXX - don't call pci_config_XXX from a thread
cntl->type = USB_TYPE_OHCI;
u32 baseaddr = pci_config_readl(cntl->bdf, PCI_BASE_ADDRESS_0);
cntl->ohci.regs = (void*)(baseaddr & PCI_BASE_ADDRESS_MEM_MASK);
dprintf(3, "OHCI init on dev %02x:%02x.%x (regs=%p)\n"
, pci_bdf_to_bus(cntl->bdf), pci_bdf_to_dev(cntl->bdf)
, pci_bdf_to_fn(cntl->bdf), cntl->ohci.regs);
// Enable bus mastering and memory access.
pci_config_maskw(cntl->bdf, PCI_COMMAND
, 0, PCI_COMMAND_MASTER|PCI_COMMAND_MEMORY);
// XXX - check for and disable SMM control?
// Disable interrupts
writel(&cntl->ohci.regs->intrdisable, ~0);
writel(&cntl->ohci.regs->intrstatus, ~0);
// Allocate memory
struct ohci_hcca *hcca = memalign_high(256, sizeof(*hcca));
struct ohci_ed *control_ed = malloc_high(sizeof(*control_ed));
if (!hcca || !control_ed) {
dprintf(1, "No ram for ohci init\n");
return;
}
memset(hcca, 0, sizeof(*hcca));
memset(control_ed, 0, sizeof(*control_ed));
control_ed->hwINFO = ED_SKIP;
cntl->ohci.control_ed = control_ed;
int ret = start_ohci(cntl, hcca);
if (ret)
goto err;
int count = check_ohci_ports(cntl);
if (! count)
goto err;
return;
err:
stop_ohci(cntl);
free(hcca);
free(control_ed);
}
/* Fill in hypercall transfer pages. */
void xen_hypercall_setup(void)
{
u32 eax, ebx, ecx, edx;
xen_extraversion_t extraversion;
unsigned long i;
if (!runningOnXen())
return;
cpuid(xen_cpuid_base + 2, &eax, &ebx, &ecx, &edx);
xen_hypercall_page = (unsigned long)memalign_high(PAGE_SIZE, eax*PAGE_SIZE);
if (!xen_hypercall_page)
panic("unable to allocate Xen hypercall page\n");
dprintf(1, "Allocated Xen hypercall page at %lx\n", xen_hypercall_page);
for ( i = 0; i < eax; i++ )
wrmsr(ebx, xen_hypercall_page + (i << 12) + i);
/* Print version information. */
cpuid(xen_cpuid_base + 1, &eax, &ebx, &ecx, &edx);
hypercall_xen_version(XENVER_extraversion, extraversion);
dprintf(1, "Detected Xen v%u.%u%s\n", eax >> 16, eax & 0xffff, extraversion);
}
static void
configure_ehci(void *data)
{
struct usb_ehci_s *cntl = data;
// Allocate ram for schedule storage
struct ehci_framelist *fl = memalign_high(sizeof(*fl), sizeof(*fl));
struct ehci_qh *intr_qh = memalign_high(EHCI_QH_ALIGN, sizeof(*intr_qh));
struct ehci_qh *async_qh = memalign_high(EHCI_QH_ALIGN, sizeof(*async_qh));
if (!fl || !intr_qh || !async_qh) {
warn_noalloc();
goto fail;
}
// XXX - check for halted?
// Reset the HC
u32 cmd = readl(&cntl->regs->usbcmd);
writel(&cntl->regs->usbcmd, (cmd & ~(CMD_ASE | CMD_PSE)) | CMD_HCRESET);
u64 end = calc_future_tsc(250);
for (;;) {
cmd = readl(&cntl->regs->usbcmd);
if (!(cmd & CMD_HCRESET))
break;
if (check_tsc(end)) {
warn_timeout();
goto fail;
}
yield();
}
// Disable interrupts (just to be safe).
writel(&cntl->regs->usbintr, 0);
// Set schedule to point to primary intr queue head
memset(intr_qh, 0, sizeof(*intr_qh));
intr_qh->next = EHCI_PTR_TERM;
intr_qh->info2 = (0x01 << QH_SMASK_SHIFT);
intr_qh->token = QTD_STS_HALT;
intr_qh->qtd_next = intr_qh->alt_next = EHCI_PTR_TERM;
int i;
for (i=0; i<ARRAY_SIZE(fl->links); i++)
fl->links[i] = (u32)intr_qh | EHCI_PTR_QH;
writel(&cntl->regs->periodiclistbase, (u32)fl);
// Set async list to point to primary async queue head
memset(async_qh, 0, sizeof(*async_qh));
async_qh->next = (u32)async_qh | EHCI_PTR_QH;
async_qh->info1 = QH_HEAD;
async_qh->token = QTD_STS_HALT;
async_qh->qtd_next = async_qh->alt_next = EHCI_PTR_TERM;
cntl->async_qh = async_qh;
writel(&cntl->regs->asynclistbase, (u32)async_qh);
// Enable queues
writel(&cntl->regs->usbcmd, cmd | CMD_ASE | CMD_PSE | CMD_RUN);
// Set default of high speed for root hub.
writel(&cntl->regs->configflag, 1);
cntl->checkports = readl(&cntl->caps->hcsparams) & HCS_N_PORTS_MASK;
// Find devices
int count = check_ehci_ports(cntl);
ehci_free_pipes(cntl);
if (count)
// Success
return;
// No devices found - shutdown and free controller.
writel(&cntl->regs->usbcmd, cmd & ~CMD_RUN);
msleep(4); // 2ms to stop reading memory - XXX
fail:
free(fl);
free(intr_qh);
free(async_qh);
free(cntl);
}
