static unsigned long *
lookup_fit(int nasid)
{
unsigned long *fitp;
unsigned long fit_paddr;
unsigned long *fit_vaddr;
#ifdef CONFIG_IA64_SGI_SN_SIM
if (IS_RUNNING_ON_SIMULATOR())
return fakefit;
#endif
fitp = (void *)GLOBAL_MMR_ADDR(nasid, LB_PROM_SPACE - 32);
DPRINTK("pointer to fit at %p\n", (void *)fitp);
fit_paddr = readq(fitp);
DPRINTK("fit pointer contains %lx\n", fit_paddr);
/* snag just the node-relative offset */
fit_paddr &= ~0ul >> (63-35);
/* the pointer to the FIT is relative to IA-64 compatibility
* space. However, the PROM is mapped at a different offset
* in MMR space (both local and global)
*/
fit_paddr += 0x700000000;
fit_vaddr = (void *)GLOBAL_MMR_ADDR(nasid, fit_paddr);
DPRINTK("fit at %p\n", (void *)fit_vaddr);
return fit_vaddr;
}
/*
* hubspc_init
* Registration of the hubspc devices with the hub manager
*/
void
hubspc_init(void)
{
/*
* Register with the hub manager
*/
/* The reference counters */
hubdev_register(mem_refcnt_attach);
/* Prom space */
hubdev_register(cpuprom_attach);
#if defined(CONFIG_SERIAL_SGI_L1_PROTOCOL)
/* L1 system controller link */
if ( !IS_RUNNING_ON_SIMULATOR() ) {
/* initialize the L1 link */
void l1_cons_init( l1sc_t *sc );
elsc_t *get_elsc(void);
l1_cons_init((l1sc_t *)get_elsc());
}
#endif
#ifdef HUBSPC_DEBUG
printf("hubspc_init: Completed\n");
#endif /* HUBSPC_DEBUG */
/* Initialize spinlocks */
mutex_spinlock_init(&cpuprom_spinlock);
}
nasid_t
snia_get_console_nasid(void)
{
extern nasid_t console_nasid;
extern nasid_t master_baseio_nasid;
if (console_nasid < 0) {
console_nasid = ia64_sn_get_console_nasid();
if (console_nasid < 0) {
// ZZZ What do we do if we don't get a console nasid on the hardware????
if (IS_RUNNING_ON_SIMULATOR() )
console_nasid = master_baseio_nasid;
}
}
return console_nasid;
}
/*
* snia64_pci_find_bios - SNIA64 pci_find_bios() platform specific code.
*/
void __init
sn1_pci_find_bios(void)
{
extern struct pci_ops pci_conf;
/*
* Go initialize our IO Infrastructure ..
*/
extern void sgi_master_io_infr_init(void);
sgi_master_io_infr_init();
#ifdef BRINGUP
if ( IS_RUNNING_ON_SIMULATOR() )
return;
#endif
/* sn1_io_infrastructure_init(); */
pci_conf = snia64_pci_ops;
}
void
klgraph_hack_init(void)
{
u64 *temp;
#ifdef CONFIG_IA64_SGI_SN1
/*
* We need to know whether we are booting from PROM or
* boot from disk.
*/
linux_klcfg = (kl_config_hdr_t *)0xe000000000030000;
if (linux_klcfg->ch_magic == 0xbeedbabe) {
return;
} else {
panic("klgraph_hack_init: Unable to locate KLCONFIG TABLE\n");
}
convert(0x0000000000030000, 0x00000000beedbabe, 0x0000004800000000);
#else
if (IS_RUNNING_ON_SIMULATOR()) {
printk("Creating FAKE Klconfig Structure for Embeded Kernel\n");
klgraph_addr[0] = 0xe000003000030000;
/*
* klconfig entries initialization - mankato
*/
convert(0xe000003000030000, 0x00000000beedbabe, 0x0000004800000000);
convert(0xe000003000030010, 0x0003007000000018, 0x800002000f820178);
convert(0xe000003000030020, 0x80000a000f024000, 0x800002000f800000);
convert(0xe000003000030030, 0x0300fafa00012580, 0x00000000040f0000);
convert(0xe000003000030040, 0x0000000000000000, 0x0003097000030070);
convert(0xe000003000030050, 0x00030970000303b0, 0x0003181000033f70);
convert(0xe000003000030060, 0x0003d51000037570, 0x0000000000038330);
convert(0xe000003000030070, 0x0203110100030140, 0x0001000000000101);
convert(0xe000003000030080, 0x0900000000000000, 0x000000004e465e67);
convert(0xe000003000030090, 0x0003097000000000, 0x00030b1000030a40);
convert(0xe0000030000300a0, 0x00030cb000030be0, 0x000315a0000314d0);
convert(0xe0000030000300b0, 0x0003174000031670, 0x0000000000000000);
convert(0xe000003000030100, 0x000000000000001a, 0x3350490000000000);
convert(0xe000003000030110, 0x0000000000000037, 0x0000000000000000);
convert(0xe000003000030140, 0x0002420100030210, 0x0001000000000101);
convert(0xe000003000030150, 0x0100000000000000, 0xffffffffffffffff);
convert(0xe000003000030160, 0x00030d8000000000, 0x0000000000030e50);
convert(0xe0000030000301c0, 0x0000000000000000, 0x0000000000030070);
convert(0xe0000030000301d0, 0x0000000000000025, 0x424f490000000000);
convert(0xe0000030000301e0, 0x000000004b434952, 0x0000000000000000);
convert(0xe000003000030210, 0x00027101000302e0, 0x00010000000e4101);
convert(0xe000003000030220, 0x0200000000000000, 0xffffffffffffffff);
convert(0xe000003000030230, 0x00030f2000000000, 0x0000000000030ff0);
convert(0xe000003000030290, 0x0000000000000000, 0x0000000000030140);
convert(0xe0000030000302a0, 0x0000000000000026, 0x7262490000000000);
convert(0xe0000030000302b0, 0x00000000006b6369, 0x0000000000000000);
convert(0xe0000030000302e0, 0x0002710100000000, 0x00010000000f3101);
convert(0xe0000030000302f0, 0x0500000000000000, 0xffffffffffffffff);
convert(0xe000003000030300, 0x000310c000000000, 0x0003126000031190);
convert(0xe000003000030310, 0x0003140000031330, 0x0000000000000000);
convert(0xe000003000030360, 0x0000000000000000, 0x0000000000030140);
convert(0xe000003000030370, 0x0000000000000029, 0x7262490000000000);
convert(0xe000003000030380, 0x00000000006b6369, 0x0000000000000000);
convert(0xe000003000030970, 0x0000000002010102, 0x0000000000000000);
convert(0xe000003000030980, 0x000000004e465e67, 0xffffffff00000000);
/* convert(0x00000000000309a0, 0x0000000000037570, 0x0000000100000000); */
convert(0xe0000030000309a0, 0x0000000000037570, 0xffffffff00000000);
convert(0xe0000030000309b0, 0x0000000000030070, 0x0000000000000000);
convert(0xe0000030000309c0, 0x000000000003f420, 0x0000000000000000);
convert(0xe000003000030a40, 0x0000000002010125, 0x0000000000000000);
convert(0xe000003000030a50, 0xffffffffffffffff, 0xffffffff00000000);
convert(0xe000003000030a70, 0x0000000000037b78, 0x0000000000000000);
convert(0xe000003000030b10, 0x0000000002010125, 0x0000000000000000);
convert(0xe000003000030b20, 0xffffffffffffffff, 0xffffffff00000000);
convert(0xe000003000030b40, 0x0000000000037d30, 0x0000000000000001);
convert(0xe000003000030be0, 0x00000000ff010203, 0x0000000000000000);
convert(0xe000003000030bf0, 0xffffffffffffffff, 0xffffffff000000ff);
convert(0xe000003000030c10, 0x0000000000037ee8, 0x0100010000000200);
convert(0xe000003000030cb0, 0x00000000ff310111, 0x0000000000000000);
convert(0xe000003000030cc0, 0xffffffffffffffff, 0x0000000000000000);
convert(0xe000003000030d80, 0x0000000002010104, 0x0000000000000000);
convert(0xe000003000030d90, 0xffffffffffffffff, 0x00000000000000ff);
convert(0xe000003000030db0, 0x0000000000037f18, 0x0000000000000000);
convert(0xe000003000030dc0, 0x0000000000000000, 0x0003007000060000);
convert(0xe000003000030de0, 0x0000000000000000, 0x0003021000050000);
convert(0xe000003000030df0, 0x000302e000050000, 0x0000000000000000);
convert(0xe000003000030e30, 0x0000000000000000, 0x000000000000000a);
convert(0xe000003000030e50, 0x00000000ff00011a, 0x0000000000000000);
convert(0xe000003000030e60, 0xffffffffffffffff, 0x0000000000000000);
convert(0xe000003000030e80, 0x0000000000037fe0, 0x9e6e9e9e9e9e9e9e);
convert(0xe000003000030e90, 0x000000000000bc6e, 0x0000000000000000);
convert(0xe000003000030f20, 0x0000000002010205, 0x00000000d0020000);
convert(0xe000003000030f30, 0xffffffffffffffff, 0x0000000e0000000e);
convert(0xe000003000030f40, 0x000000000000000e, 0x0000000000000000);
convert(0xe000003000030f50, 0x0000000000038010, 0x00000000000007ff);
convert(0xe000003000030f70, 0x0000000000000000, 0x0000000022001077);
convert(0xe000003000030fa0, 0x0000000000000000, 0x000000000003f4a8);
convert(0xe000003000030ff0, 0x0000000000310120, 0x0000000000000000);
convert(0xe000003000031000, 0xffffffffffffffff, 0xffffffff00000002);
convert(0xe000003000031010, 0x000000000000000e, 0x0000000000000000);
convert(0xe000003000031020, 0x0000000000038088, 0x0000000000000000);
convert(0xe0000030000310c0, 0x0000000002010205, 0x00000000d0020000);
convert(0xe0000030000310d0, 0xffffffffffffffff, 0x0000000f0000000f);
convert(0xe0000030000310e0, 0x000000000000000f, 0x0000000000000000);
convert(0xe0000030000310f0, 0x00000000000380b8, 0x00000000000007ff);
convert(0xe000003000031120, 0x0000000022001077, 0x00000000000310a9);
convert(0xe000003000031130, 0x00000000580211c1, 0x000000008009104c);
convert(0xe000003000031140, 0x0000000000000000, 0x000000000003f4c0);
convert(0xe000003000031190, 0x0000000000310120, 0x0000000000000000);
convert(0xe0000030000311a0, 0xffffffffffffffff, 0xffffffff00000003);
convert(0xe0000030000311b0, 0x000000000000000f, 0x0000000000000000);
convert(0xe0000030000311c0, 0x0000000000038130, 0x0000000000000000);
convert(0xe000003000031260, 0x0000000000110106, 0x0000000000000000);
convert(0xe000003000031270, 0xffffffffffffffff, 0xffffffff00000004);
convert(0xe000003000031270, 0xffffffffffffffff, 0xffffffff00000004);
convert(0xe000003000031280, 0x000000000000000f, 0x0000000000000000);
convert(0xe0000030000312a0, 0x00000000ff110013, 0x0000000000000000);
convert(0xe0000030000312b0, 0xffffffffffffffff, 0xffffffff00000000);
convert(0xe0000030000312c0, 0x000000000000000f, 0x0000000000000000);
convert(0xe0000030000312e0, 0x0000000000110012, 0x0000000000000000);
convert(0xe0000030000312f0, 0xffffffffffffffff, 0xffffffff00000000);
convert(0xe000003000031300, 0x000000000000000f, 0x0000000000000000);
convert(0xe000003000031310, 0x0000000000038160, 0x0000000000000000);
convert(0xe000003000031330, 0x00000000ff310122, 0x0000000000000000);
convert(0xe000003000031340, 0xffffffffffffffff, 0xffffffff00000005);
convert(0xe000003000031350, 0x000000000000000f, 0x0000000000000000);
convert(0xe000003000031360, 0x0000000000038190, 0x0000000000000000);
convert(0xe000003000031400, 0x0000000000310121, 0x0000000000000000);
convert(0xe000003000031400, 0x0000000000310121, 0x0000000000000000);
convert(0xe000003000031410, 0xffffffffffffffff, 0xffffffff00000006);
convert(0xe000003000031420, 0x000000000000000f, 0x0000000000000000);
convert(0xe000003000031430, 0x00000000000381c0, 0x0000000000000000);
convert(0xe0000030000314d0, 0x00000000ff010201, 0x0000000000000000);
convert(0xe0000030000314e0, 0xffffffffffffffff, 0xffffffff00000000);
convert(0xe000003000031500, 0x00000000000381f0, 0x000030430000ffff);
convert(0xe000003000031510, 0x000000000000ffff, 0x0000000000000000);
convert(0xe0000030000315a0, 0x00000020ff000201, 0x0000000000000000);
convert(0xe0000030000315b0, 0xffffffffffffffff, 0xffffffff00000001);
convert(0xe0000030000315d0, 0x0000000000038240, 0x00003f3f0000ffff);
convert(0xe0000030000315e0, 0x000000000000ffff, 0x0000000000000000);
convert(0xe000003000031670, 0x00000000ff010201, 0x0000000000000000);
convert(0xe000003000031680, 0xffffffffffffffff, 0x0000000100000002);
convert(0xe0000030000316a0, 0x0000000000038290, 0x000030430000ffff);
convert(0xe0000030000316b0, 0x000000000000ffff, 0x0000000000000000);
convert(0xe000003000031740, 0x00000020ff000201, 0x0000000000000000);
convert(0xe000003000031750, 0xffffffffffffffff, 0x0000000500000003);
convert(0xe000003000031770, 0x00000000000382e0, 0x00003f3f0000ffff);
convert(0xe000003000031780, 0x000000000000ffff, 0x0000000000000000);
}
#endif
}
static void __init scan_for_ionodes(void)
{
int nasid = 0;
lboard_t *brd;
/* Setup ionodes with memory */
for (nasid = 0; nasid < MAX_PHYSNODE_ID; nasid += 2) {
char *klgraph_header;
cnodeid_t cnodeid;
if (physical_node_map[nasid] == -1)
continue;
cnodeid = -1;
klgraph_header = __va(ia64_sn_get_klconfig_addr(nasid));
if (!klgraph_header) {
if (IS_RUNNING_ON_SIMULATOR())
continue;
BUG(); /* All nodes must have klconfig tables! */
}
cnodeid = nasid_to_cnodeid(nasid);
root_lboard[cnodeid] = (lboard_t *)
NODE_OFFSET_TO_LBOARD((nasid),
((kl_config_hdr_t
*) (klgraph_header))->
ch_board_info);
}
/* Scan headless/memless IO Nodes. */
for (nasid = 0; nasid < MAX_PHYSNODE_ID; nasid += 2) {
/* if there's no nasid, don't try to read the klconfig on the node */
if (physical_node_map[nasid] == -1)
continue;
brd = find_lboard_any((lboard_t *)
root_lboard[nasid_to_cnodeid(nasid)],
KLTYPE_SNIA);
if (brd) {
brd = KLCF_NEXT_ANY(brd); /* Skip this node's lboard */
if (!brd)
continue;
}
brd = find_lboard_any(brd, KLTYPE_SNIA);
while (brd) {
pda->cnodeid_to_nasid_table[numionodes] =
brd->brd_nasid;
physical_node_map[brd->brd_nasid] = numionodes;
root_lboard[numionodes] = brd;
numionodes++;
brd = KLCF_NEXT_ANY(brd);
if (!brd)
break;
brd = find_lboard_any(brd, KLTYPE_SNIA);
}
}
/* Scan for TIO nodes. */
for (nasid = 0; nasid < MAX_PHYSNODE_ID; nasid += 2) {
/* if there's no nasid, don't try to read the klconfig on the node */
if (physical_node_map[nasid] == -1)
continue;
brd = find_lboard_any((lboard_t *)
root_lboard[nasid_to_cnodeid(nasid)],
KLTYPE_TIO);
while (brd) {
pda->cnodeid_to_nasid_table[numionodes] =
brd->brd_nasid;
physical_node_map[brd->brd_nasid] = numionodes;
root_lboard[numionodes] = brd;
numionodes++;
brd = KLCF_NEXT_ANY(brd);
if (!brd)
break;
brd = find_lboard_any(brd, KLTYPE_TIO);
}
}
}
/*
* init_hcl() - Boot time initialization. Ensure that it is called
* after devfs has been initialized.
*
* For now this routine is being called out of devfs/base.c. Actually
* Not a bad place to be ..
*
*/
int __init init_hcl(void)
{
extern void string_table_init(struct string_table *);
extern struct string_table label_string_table;
extern int init_ifconfig_net(void);
extern int init_ioconfig_bus(void);
int status = 0;
int rv = 0;
if (IS_RUNNING_ON_SIMULATOR()) {
extern u64 klgraph_addr[];
klgraph_addr[0] = 0xe000003000030000;
}
/*
* Create the hwgraph_root on devfs.
*/
rv = hwgraph_path_add(NULL, EDGE_LBL_HW, &hwgraph_root);
if (rv)
printk ("WARNING: init_hcl: Failed to create hwgraph_root. Error = %d.\n", rv);
status = devfs_set_flags (hwgraph_root, DEVFS_FL_HIDE);
/*
* Create the hcl driver to support inventory entry manipulations.
* By default, it is expected that devfs is mounted on /dev.
*
*/
hcl_handle = hwgraph_register(hwgraph_root, ".hcl",
0, DEVFS_FL_AUTO_DEVNUM,
0, 0,
S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, 0, 0,
&hcl_fops, NULL);
if (hcl_handle == NULL) {
panic("HCL: Unable to create HCL Driver in init_hcl().\n");
return(0);
}
/*
* Initialize the HCL string table.
*/
string_table_init(&label_string_table);
/*
* Create the directory that links Linux bus numbers to our Xwidget.
*/
rv = hwgraph_path_add(hwgraph_root, EDGE_LBL_LINUX_BUS, &linux_busnum);
if (linux_busnum == NULL) {
panic("HCL: Unable to create %s\n", EDGE_LBL_LINUX_BUS);
return(0);
}
pci_bus_cvlink_init();
/*
* Initialize the ifconfgi_net driver that does network devices
* Persistent Naming.
*/
init_ifconfig_net();
init_ioconfig_bus();
return(0);
}
/*
* sn_pci_fixup() - This routine is called when platform_pci_fixup() is
* invoked at the end of pcibios_init() to link the Linux pci
* infrastructure to SGI IO Infrasturcture - ia64/kernel/pci.c
*
* Other platform specific fixup can also be done here.
*/
void
sn_pci_fixup(int arg)
{
struct list_head *ln;
struct pci_bus *pci_bus = NULL;
struct pci_dev *device_dev = NULL;
struct sn_widget_sysdata *widget_sysdata;
struct sn_device_sysdata *device_sysdata;
#ifdef SN_IOPORTS
unsigned long ioport;
#endif
pciio_intr_t intr_handle;
int cpuid, bit;
devfs_handle_t device_vertex;
pciio_intr_line_t lines;
extern void sn_pci_find_bios(void);
#ifdef CONFIG_IA64_SGI_SN2
extern int numnodes;
int cnode;
#endif /* CONFIG_IA64_SGI_SN2 */
if (arg == 0) {
sn_init_irq_desc();
sn_pci_find_bios();
#ifdef CONFIG_IA64_SGI_SN2
for (cnode = 0; cnode < numnodes; cnode++) {
extern void intr_init_vecblk(nodepda_t *npda, cnodeid_t, int);
intr_init_vecblk(NODEPDA(cnode), cnode, 0);
}
#endif /* CONFIG_IA64_SGI_SN2 */
return;
}
#if 0
{
devfs_handle_t bridge_vhdl = pci_bus_to_vertex(0);
pcibr_soft_t pcibr_soft = (pcibr_soft_t) hwgraph_fastinfo_get(bridge_vhdl);
bridge_t *bridge = pcibr_soft->bs_base;
printk("pci_fixup_ioc3: Before devreg fixup\n");
printk("pci_fixup_ioc3: Devreg 0 0x%x\n", bridge->b_device[0].reg);
printk("pci_fixup_ioc3: Devreg 1 0x%x\n", bridge->b_device[1].reg);
printk("pci_fixup_ioc3: Devreg 2 0x%x\n", bridge->b_device[2].reg);
printk("pci_fixup_ioc3: Devreg 3 0x%x\n", bridge->b_device[3].reg);
printk("pci_fixup_ioc3: Devreg 4 0x%x\n", bridge->b_device[4].reg);
printk("pci_fixup_ioc3: Devreg 5 0x%x\n", bridge->b_device[5].reg);
printk("pci_fixup_ioc3: Devreg 6 0x%x\n", bridge->b_device[6].reg);
printk("pci_fixup_ioc3: Devreg 7 0x%x\n", bridge->b_device[7].reg);
}
#endif
done_probing = 1;
/*
* Initialize the pci bus vertex in the pci_bus struct.
*/
for( ln = pci_root_buses.next; ln != &pci_root_buses; ln = ln->next) {
pci_bus = pci_bus_b(ln);
widget_sysdata = kmalloc(sizeof(struct sn_widget_sysdata),
GFP_KERNEL);
widget_sysdata->vhdl = pci_bus_to_vertex(pci_bus->number);
pci_bus->sysdata = (void *)widget_sysdata;
}
/*
* set the root start and end so that drivers calling check_region()
* won't see a conflict
*/
#ifdef SN_IOPORTS
ioport_resource.start = sn_ioport_num;
ioport_resource.end = 0xffff;
#else
#if defined(CONFIG_IA64_SGI_SN1)
if ( IS_RUNNING_ON_SIMULATOR() ) {
/*
* IDE legacy IO PORTs are supported in Medusa.
* Just open up IO PORTs from 0 .. ioport_resource.end.
*/
ioport_resource.start = 0;
} else {
/*
* We do not support Legacy IO PORT numbers.
*/
ioport_resource.start |= IO_SWIZ_BASE | __IA64_UNCACHED_OFFSET;
}
ioport_resource.end |= (HSPEC_SWIZ_BASE-1) | __IA64_UNCACHED_OFFSET;
#else
// Need something here for sn2.... ZXZXZX
#endif
#endif
/*
* Set the root start and end for Mem Resource.
*/
iomem_resource.start = 0;
iomem_resource.end = 0xffffffffffffffff;
/*
* Initialize the device vertex in the pci_dev struct.
*/
pci_for_each_dev(device_dev) {
unsigned int irq;
int idx;
u16 cmd;
devfs_handle_t vhdl;
unsigned long size;
extern int bit_pos_to_irq(int);
if (device_dev->vendor == PCI_VENDOR_ID_SGI &&
device_dev->device == PCI_DEVICE_ID_SGI_IOC3) {
extern void pci_fixup_ioc3(struct pci_dev *d);
pci_fixup_ioc3(device_dev);
}
/* Set the device vertex */
device_sysdata = kmalloc(sizeof(struct sn_device_sysdata),
GFP_KERNEL);
device_sysdata->vhdl = devfn_to_vertex(device_dev->bus->number, device_dev->devfn);
device_sysdata->isa64 = 0;
/*
* Set the xbridge Device(X) Write Buffer Flush and Xbow Flush
* register addresses.
*/
(void) set_flush_addresses(device_dev, device_sysdata);
device_dev->sysdata = (void *) device_sysdata;
set_sn_pci64(device_dev);
pci_read_config_word(device_dev, PCI_COMMAND, &cmd);
/*
* Set the resources address correctly. The assumption here
* is that the addresses in the resource structure has been
* read from the card and it was set in the card by our
* Infrastructure ..
*/
vhdl = device_sysdata->vhdl;
for (idx = 0; idx < PCI_ROM_RESOURCE; idx++) {
size = 0;
size = device_dev->resource[idx].end -
device_dev->resource[idx].start;
if (size) {
device_dev->resource[idx].start = (unsigned long)pciio_pio_addr(vhdl, 0, PCIIO_SPACE_WIN(idx), 0, size, 0, PCIIO_BYTE_STREAM);
device_dev->resource[idx].start |= __IA64_UNCACHED_OFFSET;
}
else
continue;
device_dev->resource[idx].end =
device_dev->resource[idx].start + size;
#ifdef CONFIG_IA64_SGI_SN1
/*
* Adjust the addresses to go to the SWIZZLE ..
*/
device_dev->resource[idx].start =
device_dev->resource[idx].start & 0xfffff7ffffffffff;
device_dev->resource[idx].end =
device_dev->resource[idx].end & 0xfffff7ffffffffff;
#endif
if (device_dev->resource[idx].flags & IORESOURCE_IO) {
cmd |= PCI_COMMAND_IO;
#ifdef SN_IOPORTS
ioport = sn_allocate_ioports(device_dev->resource[idx].start);
if (ioport < 0) {
printk("sn_pci_fixup: PCI Device 0x%x on PCI Bus %d not mapped to IO PORTs .. IO PORTs exhausted\n", device_dev->devfn, device_dev->bus->number);
continue;
}
pciio_config_set(vhdl, (unsigned) PCI_BASE_ADDRESS_0 + (idx * 4), 4, (res + (ioport & 0xfff)));
printk("sn_pci_fixup: ioport number %d mapped to pci address 0x%lx\n", ioport, (res + (ioport & 0xfff)));
device_dev->resource[idx].start = ioport;
device_dev->resource[idx].end = ioport + SN_IOPORTS_UNIT;
#endif
}
if (device_dev->resource[idx].flags & IORESOURCE_MEM)
cmd |= PCI_COMMAND_MEMORY;
}
/*
* Now handle the ROM resource ..
*/
size = device_dev->resource[PCI_ROM_RESOURCE].end -
device_dev->resource[PCI_ROM_RESOURCE].start;
if (size) {
device_dev->resource[PCI_ROM_RESOURCE].start =
(unsigned long) pciio_pio_addr(vhdl, 0, PCIIO_SPACE_ROM, 0,
size, 0, PCIIO_BYTE_STREAM);
device_dev->resource[PCI_ROM_RESOURCE].start |= __IA64_UNCACHED_OFFSET;
device_dev->resource[PCI_ROM_RESOURCE].end =
device_dev->resource[PCI_ROM_RESOURCE].start + size;
#ifdef CONFIG_IA64_SGI_SN1
/*
* go through synergy swizzled space
*/
device_dev->resource[PCI_ROM_RESOURCE].start &= 0xfffff7ffffffffffUL;
device_dev->resource[PCI_ROM_RESOURCE].end &= 0xfffff7ffffffffffUL;
#endif
}
/*
* Update the Command Word on the Card.
*/
cmd |= PCI_COMMAND_MASTER; /* If the device doesn't support */
/* bit gets dropped .. no harm */
pci_write_config_word(device_dev, PCI_COMMAND, cmd);
pci_read_config_byte(device_dev, PCI_INTERRUPT_PIN, (unsigned char *)&lines);
if (device_dev->vendor == PCI_VENDOR_ID_SGI &&
device_dev->device == PCI_DEVICE_ID_SGI_IOC3 ) {
lines = 1;
}
device_sysdata = (struct sn_device_sysdata *)device_dev->sysdata;
device_vertex = device_sysdata->vhdl;
intr_handle = pciio_intr_alloc(device_vertex, NULL, lines, device_vertex);
bit = intr_handle->pi_irq;
cpuid = intr_handle->pi_cpu;
#ifdef CONFIG_IA64_SGI_SN1
irq = bit_pos_to_irq(bit);
#else /* SN2 */
irq = bit;
#endif
irq = irq + (cpuid << 8);
pciio_intr_connect(intr_handle);
device_dev->irq = irq;
#ifdef ajmtestintr
{
int slot = PCI_SLOT(device_dev->devfn);
static int timer_set = 0;
pcibr_intr_t pcibr_intr = (pcibr_intr_t)intr_handle;
pcibr_soft_t pcibr_soft = pcibr_intr->bi_soft;
extern void intr_test_handle_intr(int, void*, struct pt_regs *);
if (!timer_set) {
intr_test_set_timer();
timer_set = 1;
}
intr_test_register_irq(irq, pcibr_soft, slot);
request_irq(irq, intr_test_handle_intr,0,NULL, NULL);
}
#endif
}
#if 0
{
devfs_handle_t bridge_vhdl = pci_bus_to_vertex(0);
pcibr_soft_t pcibr_soft = (pcibr_soft_t) hwgraph_fastinfo_get(bridge_vhdl);
bridge_t *bridge = pcibr_soft->bs_base;
printk("pci_fixup_ioc3: Before devreg fixup\n");
printk("pci_fixup_ioc3: Devreg 0 0x%x\n", bridge->b_device[0].reg);
printk("pci_fixup_ioc3: Devreg 1 0x%x\n", bridge->b_device[1].reg);
printk("pci_fixup_ioc3: Devreg 2 0x%x\n", bridge->b_device[2].reg);
printk("pci_fixup_ioc3: Devreg 3 0x%x\n", bridge->b_device[3].reg);
printk("pci_fixup_ioc3: Devreg 4 0x%x\n", bridge->b_device[4].reg);
printk("pci_fixup_ioc3: Devreg 5 0x%x\n", bridge->b_device[5].reg);
printk("pci_fixup_ioc3: Devreg 6 0x%x\n", bridge->b_device[6].reg);
printk("pci_fixup_ioc3: Devreg 7 0x%x\n", bridge->b_device[7].reg);
}
printk("testing Big Window: 0xC0000200c0000000 %p\n", *( (volatile uint64_t *)0xc0000200a0000000));
printk("testing Big Window: 0xC0000200c0000008 %p\n", *( (volatile uint64_t *)0xc0000200a0000008));
#endif
}
