URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [sbus/] [sbus.c] - Rev 1765
Compare with Previous | Blame | View Log
/* sbus.c: SBus support routines. * * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) */ #include <linux/kernel.h> #include <linux/malloc.h> #include <asm/system.h> #include <asm/sbus.h> #include <asm/dma.h> #include <asm/oplib.h> /* This file has been written to be more dynamic and a bit cleaner, * but it still needs some spring cleaning. */ struct linux_sbus *SBus_chain; static char lbuf[128]; /* Perhaps when I figure out more about the iommu we'll put a * device registration routine here that probe_sbus() calls to * setup the iommu for each Sbus. */ /* We call this for each SBus device, and fill the structure based * upon the prom device tree. We return the start of memory after * the things we have allocated. */ /* #define DEBUG_FILL */ void fill_sbus_device(int nd, struct linux_sbus_device *sbus_dev) { int grrr, len; unsigned long dev_base_addr, base; sbus_dev->prom_node = nd; prom_getstring(nd, "name", lbuf, sizeof(lbuf)); strcpy(sbus_dev->prom_name, lbuf); dev_base_addr = prom_getint(nd, "address"); if(dev_base_addr != -1) sbus_dev->sbus_addr = dev_base_addr; len = prom_getproperty(nd, "reg", (void *) sbus_dev->reg_addrs, sizeof(sbus_dev->reg_addrs)); if(len%sizeof(struct linux_prom_registers)) { prom_printf("WHOOPS: proplen for %s was %d, need multiple of %d\n", sbus_dev->prom_name, len, (int) sizeof(struct linux_prom_registers)); panic("fill_sbus_device"); } sbus_dev->num_registers = (len/sizeof(struct linux_prom_registers)); base = (unsigned long) sbus_dev->reg_addrs[0].phys_addr; if(base>=SUN_SBUS_BVADDR || sparc_cpu_model == sun4m) { /* Ahh, we can determine the slot and offset */ sbus_dev->slot = sbus_dev_slot(base); sbus_dev->offset = sbus_dev_offset(base); } else { /* Grrr, gotta do calculations to fix things up */ sbus_dev->slot = sbus_dev->reg_addrs[0].which_io; sbus_dev->offset = base; sbus_dev->reg_addrs[0].phys_addr = (char *) sbus_devaddr(sbus_dev->slot, base); for(grrr=1; grrr<sbus_dev->num_registers; grrr++) { base = (unsigned long) sbus_dev->reg_addrs[grrr].phys_addr; sbus_dev->reg_addrs[grrr].phys_addr = (char *) sbus_devaddr(sbus_dev->slot, base); } /* That surely sucked */ } sbus_dev->sbus_addr = (unsigned long) sbus_dev->reg_addrs[0].phys_addr; if(len>(sizeof(struct linux_prom_registers)*PROMREG_MAX)) { prom_printf("WHOOPS: I got too many register addresses for %s len=%d\n", sbus_dev->prom_name, len); panic("sbus device register overflow"); } len = prom_getproperty(nd, "address", (void *) sbus_dev->sbus_vaddrs, sizeof(sbus_dev->sbus_vaddrs)); if(len == -1) len=0; if(len&3) { prom_printf("Grrr, I didn't get a multiple of 4 proplen " "for device %s got %d\n", sbus_dev->prom_name, len); len=0; } sbus_dev->num_vaddrs = (len/4); len = prom_getproperty(nd, "intr", (void *)sbus_dev->irqs, sizeof(sbus_dev->irqs)); if (len == -1) len=0; if (len&7) { prom_printf("Grrr, I didn't get a multiple of 8 proplen for " "device %s got %d\n", sbus_dev->prom_name, len); len=0; } sbus_dev->num_irqs=(len/8); #if OLD_STYLE_IRQ /* Grrr, V3 prom tries to be efficient */ for(len=0; len<sbus_dev->num_irqs; len++) { sbus_dev->irqs[len].pri &= 0xf; } #endif if(sbus_dev->num_irqs == 0) sbus_dev->irqs[0].pri=0; #ifdef DEBUG_FILL prom_printf("Found %s at SBUS slot %x offset %08lx irq-level %d\n", sbus_dev->prom_name, sbus_dev->slot, sbus_dev->offset, sbus_dev->irqs[0].pri); prom_printf("Base address %08lx\n", sbus_dev->sbus_addr); prom_printf("REGISTERS: Probed %d register(s)\n", sbus_dev->num_registers); for(len=0; len<sbus_dev->num_registers; len++) prom_printf("Regs<%d> at address<%08lx> IO-space<%d> size<%d " "bytes, %d words>\n", (int) len, (unsigned long) sbus_dev->reg_addrs[len].phys_addr, sbus_dev->reg_addrs[len].which_io, sbus_dev->reg_addrs[len].reg_size, (sbus_dev->reg_addrs[len].reg_size/4)); #endif return; } /* This routine gets called from whoever needs the sbus first, to scan * the SBus device tree. Currently it just prints out the devices * found on the bus and builds trees of SBUS structs and attached * devices. */ extern void sun_console_init(void); extern unsigned long iommu_init(int iommu_node, unsigned long memstart, unsigned long memend, struct linux_sbus *sbus); unsigned long sbus_init(unsigned long memory_start, unsigned long memory_end) { register int nd, this_sbus, sbus_devs, topnd, iommund; unsigned int sbus_clock; struct linux_sbus *sbus; struct linux_sbus_device *this_dev; int num_sbus = 0; /* How many did we find? */ memory_start = ((memory_start + 7) & (~7)); topnd = prom_getchild(prom_root_node); /* Finding the first sbus is a special case... */ iommund = 0; if((nd = prom_searchsiblings(topnd, "sbus")) == 0) { if((iommund = prom_searchsiblings(topnd, "iommu")) == 0 || (nd = prom_getchild(iommund)) == 0 || (nd = prom_searchsiblings(nd, "sbus")) == 0) { /* No reason to run further - the data access trap will occur. */ panic("sbus not found"); } } /* Ok, we've found the first one, allocate first SBus struct * and place in chain. */ sbus = SBus_chain = (struct linux_sbus *) memory_start; memory_start += sizeof(struct linux_sbus); sbus->next = 0; this_sbus=nd; /* Have IOMMU will travel. XXX grrr - this should be per sbus... */ if(iommund) memory_start = iommu_init(iommund, memory_start, memory_end, sbus); /* Loop until we find no more SBUS's */ while(this_sbus) { printk("sbus%d: ", num_sbus); sbus_clock = prom_getint(this_sbus, "clock-frequency"); if(sbus_clock==-1) sbus_clock = (25*1000*1000); printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000), (int) (((sbus_clock/1000)%1000 != 0) ? (((sbus_clock/1000)%1000) + 1000) : 0)); prom_getstring(this_sbus, "name", lbuf, sizeof(lbuf)); sbus->prom_node = this_sbus; strcpy(sbus->prom_name, lbuf); sbus->clock_freq = sbus_clock; sbus_devs = prom_getchild(this_sbus); sbus->devices = (struct linux_sbus_device *) memory_start; memory_start += sizeof(struct linux_sbus_device); this_dev = sbus->devices; this_dev->next = 0; fill_sbus_device(sbus_devs, this_dev); this_dev->my_bus = sbus; /* Should we traverse for children? */ if(strcmp(this_dev->prom_name, "espdma")==0 || strcmp(this_dev->prom_name, "ledma")==0) { /* Allocate device node */ this_dev->child = (struct linux_sbus_device *) memory_start; memory_start += sizeof(struct linux_sbus_device); /* Fill it */ fill_sbus_device(prom_getchild(sbus_devs), this_dev->child); this_dev->child->my_bus = sbus; } else { this_dev->child = 0; } while((sbus_devs = prom_getsibling(sbus_devs)) != 0) { /* Allocate device node */ this_dev->next = (struct linux_sbus_device *) memory_start; memory_start += sizeof(struct linux_sbus_device); this_dev=this_dev->next; this_dev->next=0; /* Fill it */ fill_sbus_device(sbus_devs, this_dev); this_dev->my_bus = sbus; /* Is there a child node hanging off of us? */ if(strcmp(this_dev->prom_name, "espdma")==0 || strcmp(this_dev->prom_name, "ledma")==0) { /* Get new device struct */ this_dev->child = (struct linux_sbus_device *) memory_start; memory_start += sizeof(struct linux_sbus_device); /* Fill it */ fill_sbus_device(prom_getchild(sbus_devs), this_dev->child); this_dev->child->my_bus = sbus; } else { this_dev->child = 0; } } memory_start = dvma_init(sbus, memory_start); num_sbus++; this_sbus = prom_getsibling(this_sbus); if(!this_sbus) break; this_sbus = prom_searchsiblings(this_sbus, "sbus"); if(this_sbus) { sbus->next = (struct linux_sbus *) memory_start; memory_start += sizeof(struct linux_sbus); sbus = sbus->next; sbus->next = 0; } else { break; } } /* while(this_sbus) */ sun_console_init(); /* whee... */ return memory_start; }