int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "Usage: %s <uio-dev>\n", argv[0]);
return 1;
}
const int fd = open(argv[1], O_RDWR);
if (fd < 0) {
perror("Failed to open uio device");
return 2;
}
ehci_bar =
mmap(NULL, 1 << 8, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (MAP_FAILED == ehci_bar) {
perror("Failed to map ehci bar");
close(fd);
return 3;
}
ioperm(0x80, 1, 1);
pci_access = pci_alloc();
pci_init(pci_access);
usbdebug_init();
pci_cleanup(pci_access);
munmap(ehci_bar, 1 << 8);
close(fd);
return 0;
}
static int32
pci_old_module_std_ops(int32 op, ...)
{
switch (op) {
case B_MODULE_INIT:
{
status_t status;
TRACE(("PCI: pci_module_init\n"));
status = pci_init();
if (status < B_OK)
return status;
pci_print_info();
return B_OK;
}
case B_MODULE_UNINIT:
TRACE(("PCI: pci_module_uninit\n"));
pci_uninit();
return B_OK;
}
return B_BAD_VALUE;
}
void kmain(s64 magic, s64 info)
{
//vga_clear(COLOR_BLACK);
idt_init();
isr_init();
serial_init();
set_debug_traps();
BREAKPOINT();
cpuid_print();
multiboot(magic, info);
kmem_map();
page_init();
kmalloc_init();
//vesa_init();
root_init();
pci_init();
vm_init();
syscall_init();
timer_init();
kbd_init();
//mouse_init();
console_init();
create_kthread(NULL, idle_thread, THREAD_PRI_LOW, NULL, NULL);
create_kthread(NULL, init_thread, THREAD_PRI_NORMAL, NULL, NULL);
thread_schedule();
}
pci& pci::operator=(const pci &p) {
*this = p;
pci_init(_pacc);
_pacc->numeric_ids = 0;
pci_set_param(_pacc, const_cast<char*>("proc.path"), pci_get_param(p._pacc, const_cast<char*>("proc.path")));
return *this;
}
/* --- implementations --- */
int detect_pci22(void){
unsigned int c;
char counter=0;
pacc = pci_alloc(); /* Get the pci_access structure */
pci_init(pacc); /* Initialize the PCI library */
pci_scan_bus(pacc); /* We want to get the list of devices */
/* Iterate over all PCI devices */
for(pci22_dev=pacc->devices; pci22_dev; pci22_dev=pci22_dev->next){
pci_fill_info(pci22_dev, PCI_FILL_IDENT | PCI_FILL_BASES);
// Detect the specified device
if( (pci22_dev->vendor_id == PCI22_PCI_VENDOR_ID) &&
(pci22_dev->device_id == PCI22_PCI_DEVICE_ID)
){
break;
}
}
if (pci22_dev==NULL){
printf("\n\nERROR: PCI22 card not detected\n\n\n");
exit(0);
}
printf("\n\nPCI22 card detected on %02x:%02x.%d\nVendorID=%04x DeviceID=%04x irq=%d\n",
pci22_dev->bus,pci22_dev->dev,
pci22_dev->func,pci22_dev->vendor_id,
pci22_dev->device_id,
pci22_dev->irq);
printf("\n\n--- Baseaddresses ---\n");
printf("BAR1 %x\n",pci22_dev->base_addr[0]);
printf("BAR2 %x\n",pci22_dev->base_addr[1]);
printf("BAR3 %x\n",pci22_dev->base_addr[2]);
printf("BAR4 %x\n",pci22_dev->base_addr[3]);
printf("BAR5 %x\n",pci22_dev->base_addr[4]);
printf("BAR6 %x\n",pci22_dev->base_addr[6]);
printf("\n");
//printPCIDevice(pci22_dev);
/* The baseaddress of the COM20022 is at BAR2 */
//g_pci22dipswitch = pci22_dev->base_addr[1]; //Nonworking
g_pci22base = pci22_dev->base_addr[2];
/* Close everything */
pci_cleanup(pacc);
return 0;
}
/*===========================================================================*
* root_pci *
*===========================================================================*/
static void root_pci(void)
{
/* Print information about PCI devices present in the system.
*/
u16_t vid, did;
u8_t bcr, scr, pifr;
char *slot_name, *dev_name;
int r, devind;
static int first = TRUE;
/* This should be taken care of behind the scenes by the PCI lib. */
if (first) {
pci_init();
first = FALSE;
}
/* Iterate over all devices, printing info for each of them. */
r = pci_first_dev(&devind, &vid, &did);
while (r == 1) {
slot_name = pci_slot_name(devind);
dev_name = pci_dev_name(vid, did);
bcr = pci_attr_r8(devind, PCI_BCR);
scr = pci_attr_r8(devind, PCI_SCR);
pifr = pci_attr_r8(devind, PCI_PIFR);
buf_printf("%s %x/%x/%x %04X:%04X %s\n",
slot_name ? slot_name : "-",
bcr, scr, pifr, vid, did,
dev_name ? dev_name : "");
r = pci_next_dev(&devind, &vid, &did);
}
}
void _benmain(void)
{
struct FIFO32 fifo;
int keybuf[128]={0};
fifo32_init(&fifo, 128, keybuf);
struct TSS32 tss_a = {0};
cons_init();
env_init();
/* keyboard setting */
init_kb(&fifo, 256);
tss_a.ldtr = 0;
tss_a.iomap = 0x40000000;
set_segmdesc(gdt + 0, 103, (int) &tss_a, AR_TSS32);
task_init(memman);
/* Unfortunate try the switch back to 0*8 (_benmain) with farjmp but not working.
* And the reason still unknown.
* So that I use another thread_kb_io() to catch the keyboard interrupt.
*/
load_tr(0 * 8); // record current working task to tss_a
task_create((int) &thread_kb_io, memman, "bshell", 1);
task_create((int) &thread_events, memman, "events", 0);
/* strange issue encountered if run pci_init at the setup_hw() */
puts("pci scan bus\n");
pci_init();
farjmp(0, 4*8);
puts("\nSystem Halted \n");
_syshalt();
}
int pci_init_r(void)
{
/* Do pci configuration */
pci_init();
return 0;
}
/*---------------------------------------------------------------------------*/
usys dev_init (void)
{
usys status = GOOD ;
pci_t pci ;
/* Initialize the Clock */
if (clk_init() != GOOD)
status = BAD ;
/* Initialize the Serial Port */
if (serial_init() != GOOD)
status = BAD ;
/* Initialize the Keyboard */
if (pc_kbd_init () != GOOD)
status = BAD ;
pci.pci_write = pci_write ;
pci.pci_read = pci_read ;
if (pci_init(&pci) != GOOD)
status = BAD ;
return status ;
} /* End of function dev_init() */
void at_um8881f_init()
{
at_init();
mouse_serial_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
um8881f_init();
}
/*===========================================================================*
* atl2_probe *
*===========================================================================*/
static int atl2_probe(int skip)
{
/* Find a matching PCI device.
*/
u16_t vid, did;
char *dname;
int r, devind;
pci_init();
r = pci_first_dev(&devind, &vid, &did);
if (r <= 0)
return -1;
while (skip--) {
r = pci_next_dev(&devind, &vid, &did);
if (r <= 0)
return -1;
}
dname = pci_dev_name(vid, did);
ATL2_DEBUG(("ATL2: found %s (%x/%x) at %s\n",
dname ? dname : "<unknown>", vid, did,
pci_slot_name(devind)));
pci_reserve(devind);
return devind;
}
void at_sis496_init()
{
at_init();
mouse_serial_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
device_add(&sis496_device);
}
/*------------------------------------------------------------------
* platinit - platform specific initialization for Galileo
*------------------------------------------------------------------
*/
void platinit()
{
int32 pcidev;
/* Initialize the PCI bus */
pci_init();
/* Initialize the console serial port */
console_init();
/* Remove Isolated Memory Region Protections */
remove_irm_protections();
/* Intel Quark Irq Routing */
quark_irq_routing();
/* Find the Ethernet device */
pcidev = find_pci_device(INTEL_ETH_QUARK_PCI_DID,
INTEL_ETH_QUARK_PCI_VID, 0);
if(pcidev != SYSERR) {
/* Store the pcidev for future use */
ethertab[0].pcidev = pcidev;
pci_get_dev_mmio_base_addr(pcidev, 0,
&devtab[ETHER0].dvcsr);
}
}
static struct pci_dev *
create_pci_dev(struct pci_access * pci, char * slot)
{
struct pci_filter filter;
pci_filter_init(pci, &filter);
if (pci_filter_parse_slot(&filter, slot))
{
fprintf(stderr, "Failed to parse device id %s\n", slot);
goto pci_filter_parse_failed;
}
pci_init(pci);
struct pci_dev * dev = pci_get_dev(pci,
filter.domain,
filter.bus,
filter.slot,
filter.func);
if (! dev)
{
fprintf(stderr, "Failed to allocate dev\n");
goto pci_get_dev_failed;
}
pci_fill_info(dev, PCI_FILL_IDENT);
return dev;
pci_get_dev_failed:
pci_filter_parse_failed:
return NULL;
}
/*===========================================================================*
* vbox_init *
*===========================================================================*/
static int vbox_init(int UNUSED(type), sef_init_info_t *UNUSED(info))
{
/* Initialize the device. */
int devind;
u16_t vid, did;
struct VMMDevReportGuestInfo *req;
int r;
interval = DEFAULT_INTERVAL;
drift = DEFAULT_DRIFT;
if (env_argc > 1)
optset_parse(optset_table, env_argv[1]);
pci_init();
r = pci_first_dev(&devind, &vid, &did);
for (;;) {
if (r != 1)
panic("backdoor device not found");
if (vid == VMMDEV_PCI_VID && did == VMMDEV_PCI_DID)
break;
r = pci_next_dev(&devind, &vid, &did);
}
pci_reserve(devind);
port = pci_attr_r32(devind, PCI_BAR) & PCI_BAR_IO_MASK;
irq = pci_attr_r8(devind, PCI_ILR);
hook_id = 0;
if ((r = sys_irqsetpolicy(irq, 0 /* IRQ_REENABLE */, &hook_id)) != OK)
panic("unable to register IRQ: %d", r);
if ((r = sys_irqenable(&hook_id)) != OK)
panic("unable to enable IRQ: %d", r);
if ((vir_ptr = alloc_contig(VMMDEV_BUF_SIZE, 0, &phys_ptr)) == NULL)
panic("unable to allocate memory");
req = (struct VMMDevReportGuestInfo *) vir_ptr;
req->add_version = VMMDEV_GUEST_VERSION;
req->os_type = VMMDEV_GUEST_OS_OTHER;
if ((r = vbox_request(&req->header, phys_ptr,
VMMDEV_REQ_REPORTGUESTINFO, sizeof(*req))) !=
VMMDEV_ERR_OK)
panic("backdoor device not functioning");
ticks = sys_hz() * interval;
sys_setalarm(ticks, 0);
return OK;
}
void
i386_init(void)
{
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
cprintf("6828 decimal is %o octal!\n", 6828);
// Lab 2 memory management initialization functions
i386_detect_memory();
i386_vm_init();
// Lab 3 user environment initialization functions
env_init();
idt_init();
// Lab 4 multitasking initialization functions
pic_init();
kclock_init();
time_init();
pci_init();
// Should always have an idle process as first one.
ENV_CREATE(user_idle);
// Start fs.
ENV_CREATE(fs_fs);
#if !defined(TEST_NO_NS)
// Start ns.
ENV_CREATE(net_ns);
#endif
#if defined(TEST)
// Don't touch -- used by grading script!
ENV_CREATE2(TEST, TESTSIZE);
#else
// Touch all you want.
// ENV_CREATE(net_testoutput);
// ENV_CREATE(user_echosrv);
// ENV_CREATE(user_httpd);
// ENV_CREATE(user_writemotd);
// ENV_CREATE(user_testfile);
ENV_CREATE(user_icode);
// ENV_CREATE(user_primes);
#endif // TEST*
// Schedule and run the first user environment!
sched_yield();
}
int misc_init_r (void)
{
#ifdef CONFIG_PCI
pci_init();
#endif
setenv("verify", "n");
return (0);
}
static int initr_pci(void)
{
#ifndef CONFIG_DM_PCI
pci_init();
#endif
return 0;
}
static int init(int channel)
{
char temp[64];
pci_bus_cookie *current_cookie = kmalloc(sizeof(pci_bus_cookie));
current_cookie->channel = channel;
pci_init(current_cookie);
//return -1;
bus_cookies[channel] = current_cookie;
current_cookie->dma_supported = true;
sprintf(temp, "pci_ide_sem%d", channel);
current_cookie->bus_semaphore = sem_create(1, temp);
if(current_cookie->bus_semaphore < 0)
{
kfree(current_cookie);
return -1;
}
TRACE(("trying to discover devices on channel %d\n",channel));
if(channel==0)
{
current_cookie->base_reg = 0x1f0;
current_cookie->status_reg = 0x3f0;
}
else
{
current_cookie->base_reg = 0x170;
current_cookie->status_reg = 0x370;
}
if(ide_raw_init(current_cookie)==0)
{
int current_drive;
init_dma(current_cookie);
for(current_drive=0;current_drive<2;current_drive++)
{
int i = 0;
current_cookie->drives[current_drive] = NULL;
TRACE(("trying to discover device %d/%d\n",channel,current_drive));
while(ide_drives[i]!=NULL)
{
void *drive_cookie = ide_drives[i]->init_drive(&pci_bus,current_cookie,channel,current_drive);
if(drive_cookie!=NULL)
{
TRACE(("trying to discover device %d/%d is a %s\n",channel,current_drive,ide_drives[i]->device_name));
current_cookie->drives[current_drive] = ide_drives[i];
current_cookie->drive_cookie[current_drive] = drive_cookie;
init_ide_struct(channel,current_drive,-1);
TRACE(("done discovering device\n"));
TRACE(("Cookie for interrupt is %p\n",current_cookie));
int_set_io_interrupt_handler(14,&ide_interrupt_handler, current_cookie);
break;
}
i++;
}
}
return 0;
}
return -1;
}
int iface_desc(const char *iface, char *desc, int size)
{
struct ifreq ifr;
int fd, err, len, device, vendor;
struct ethtool_drvinfo drvinfo;
char buf[512], path[PATH_MAX];
struct pci_access *pacc;
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, iface);
fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0)
{
perror("Cannot get control socket");
return 1;
}
drvinfo.cmd = ETHTOOL_GDRVINFO;
ifr.ifr_data = (caddr_t)&drvinfo;
err = ioctl(fd, SIOCETHTOOL, &ifr);
if (err < 0)
{
perror("Cannot get driver information");
printf("%d\n", errno);
return 2;
}
close(fd);
snprintf(path, PATH_MAX-1, "/sys/bus/pci/devices/%s/vendor", drvinfo.bus_info);
fd = open(path, O_RDONLY);
if (fd < 0)
{
perror("Cannot open the vendor file");
return 3;
}
len = read(fd, buf, sizeof(buf));
buf[len-1] = '\0';
close(fd);
sscanf(buf,"%X", &vendor);
snprintf(path, PATH_MAX, "/sys/bus/pci/devices/%s/device", drvinfo.bus_info);
fd = open(path, O_RDONLY);
if (fd < 0)
{
perror("Cannot open the device file");
return 3;
}
len = read(fd, buf, sizeof(buf));
buf[len-1] = '\0';
close(fd);
sscanf(buf,"%X", &device);
pacc = pci_alloc();
pci_init(pacc);
pci_lookup_name(pacc, desc, size,
PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
vendor, device);
pci_cleanup(pacc);
return(0);
}
void at_i430vx_init()
{
at_init();
mouse_serial_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
i430vx_init();
piix_init(7);
um8669f_init();
}
void at_batman_init()
{
at_init();
mouse_ps2_init();
pci_init(PCI_CONFIG_TYPE_2, 0xd, 0x10);
i430lx_init();
fdc37c665_init();
intel_batman_init();
}
void _benmain(void)
{
int i;
int c = 0;
int keybuf[128]={0};
struct FIFO32 fifo;
struct TIMER *timer;
fifo32_init(&fifo, 128, keybuf);
struct TSS32 tss_a, tss_c;
env_init();
/* keyboard setting */
init_kb(&fifo, 256);
i=0;
timer = timer_alloc();
timer_init(timer, &fifo, 1);
timer_settime(timer, 50);
tss_a.ldtr = 0;
tss_a.iomap = 0x40000000;
tss_c.ldtr = 0;
tss_c.iomap = 0x40000000;
set_segmdesc(gdt + 3, 103, (int) &tss_a, AR_TSS32);
task_init(memman);
/* Unfortunate try the switch back to 3*8 (_benmain) with farjmp but not working.
* And the reason still unknown.
* So that I use another thread_kb_io() to catch the keyboard interrupt.
*/
load_tr(3 * 8); // record current working task to tss_a
task_create((int) &thread_kb_io, memman, "bshell");
/* strange issue encountered if run pci_init at the setup_hw() */
puts("pci scan bus\n");
pci_init();
for (;;) {
asm_cli();
if (fifo32_status(&fifo) == 0) {
asm_stihlt(); // wake while keyboard input
// got a interrupt
} else { /* scan_code input */
c=fifo32_get(&fifo);
asm_sti();
if (c == 1) {
farjmp(0, 4*8);
} else {
puts("disabled boot options.\n");
}
}
}
puts("\nSystem Halted \n");
_syshalt();
}
int dev_scan(char* buf)
{
int ret, len, index;
pci_info_t data;
ret = pci_init();
if(ret) {
printf("error init pci\n");
return ret;
}
data = scan_pci();
index = 0;
while(data != NULL) {
if(index) {
sprintf(buf, "\n PCI Controller %d:\n", index);
} else {
sprintf(buf, " PCI Controller %d:\n", index);
}
len = strlen(buf);
buf = buf + len;
sprintf(buf, " Vendor ID:%04x\n", data->ven_id);
len = strlen(buf);
buf = buf + len;
sprintf(buf, " Device ID:%04x\n", data->dev_id);
len = strlen(buf);
buf = buf + len;
sprintf(buf, " Class Code:%08x\n", data->class_code);
len = strlen(buf);
buf = buf + len;
sprintf(buf, " Sub VID:%04x\n", data->sven_id);
len = strlen(buf);
buf = buf + len;
sprintf(buf, " Sub DID:%04x\n", data->subsys_id);
len = strlen(buf);
buf = buf + len;
sprintf(buf, " Revision ID:%02x\n", data->rev_id);
len = strlen(buf);
buf = buf + len;
index ++;
data = data->next;
}
pci_fini();
return ret;
}
int main(void){
pci_init();
#ifdef ENABLE_FASTCGI
while(FCGI_Accept() >= 0) {
#endif
qentry_t *req = qcgireq_parse(NULL, 0);
char *name = req->getstr(req, "username", true);
if(name == NULL){
qcgires_redirect(req, BAD_REGISTER);
goto end;
}
char *admin = req->getstr(req, "adminpassword", true);
if(admin == NULL){
qcgires_redirect(req, BAD_REGISTER);
free(name);
goto end;
}
if(strncmp(admin, ADMIN_SECRET, strlen(ADMIN_SECRET)) != 0){
fprintf(stderr, "%s%s\n", "Invalid Registration Attempt: ", admin);
qcgires_redirect(req, BAD_REGISTER);
free(name);
free(admin);
goto end;
}
if( create_user(name) == 1 ){
/* Log the User in */
qentry_t *sess = NULL;
sess = qcgisess_init(req, NULL);
qcgisess_settimeout(sess, SESSION_TIME);
if(sess){
sess->putstr(sess, "username", name, true);
qcgisess_save(sess);
sess->free(sess);
}
qcgires_redirect(req, APPLICATION);
}else{
fprintf(stderr, "%s%s\n", "Could not create user: "******"text/html");
// De-allocate memories
req->free(req);
#ifdef ENABLE_FASTCGI
}
#endif
return 0;
}
void at_p55va_init()
{
at_init();
mouse_serial_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
i430vx_init();
piix3_init(7);
fdc37c932fr_init();
device_add(&intel_flash_bxt_device);
}
void at_i430vx_init()
{
at_init();
mouse_serial_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
i430vx_init();
piix3_init(7);
um8669f_init();
device_add(&intel_flash_bxt_device);
}
void at_p55t2p4_init()
{
at_init();
mouse_ps2_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
i430hx_init();
piix3_init(7);
w83877f_init();
device_add(&intel_flash_bxt_device);
}
void at_acerv35n_init()
{
at_init();
mouse_ps2_init();
pci_init(PCI_CONFIG_TYPE_1, 0xd, 0x10);
i430hx_init();
piix3_init(7);
fdc37c932fr_init();
acerm3a_io_init();
device_add(&intel_flash_bxb_device);
}
void at_mb500n_init()
{
at_init();
mouse_serial_init();
pci_init(PCI_CONFIG_TYPE_1, 0, 31);
i430fx_init();
piix_init(7);
fdc37c665_init();
intel_endeavor_init();
device_add(&intel_flash_bxt_device);
}
