int __init
hydra_init(void)
{
struct device_node *np;
np = find_devices("mac-io");
if (np == NULL || np->n_addrs == 0) {
printk(KERN_WARNING "Warning: no mac-io found\n");
return 0;
}
Hydra = ioremap(np->addrs[0].address, np->addrs[0].size);
printk("Hydra Mac I/O at %x\n", np->addrs[0].address);
out_le32(&Hydra->Feature_Control, (HYDRA_FC_SCC_CELL_EN |
HYDRA_FC_SCSI_CELL_EN |
HYDRA_FC_SCCA_ENABLE |
HYDRA_FC_SCCB_ENABLE |
HYDRA_FC_ARB_BYPASS |
HYDRA_FC_MPIC_ENABLE |
HYDRA_FC_SLOW_SCC_PCLK |
HYDRA_FC_MPIC_IS_MASTER));
OpenPIC_Addr = &Hydra->OpenPIC;
OpenPIC_InitSenses = hydra_openpic_initsenses;
OpenPIC_NumInitSenses = sizeof(hydra_openpic_initsenses);
return 1;
}
int main(int argc, char **argv)
{
int rtn,i,pid;
char cha,str[30];
//rtn = log_progress("1");
system("cd /Users/laurenceschenk/mini-src/mySrc/");
rtn = shared_memory_attach();
rtn = find_local();
rtn = mk_daemon(argc,argv); //must have this to write PID file
rtn = shared_memory_attach();
Mask = COLDIPOZZO_SEND | ROCCAMORICE_SEND | STARLIGHT_SEND | WEEHAWKEN_SEND ;
rtn = find_devices();
//rtn = log_progress("Main program starting....\n");
system("cd /Users/laurenceschenk/mini-src/mySrc/coldipozzo");
rtn = getuid();
sprintf(str,"uid = %d",rtn);
//rtn = log_progress(str);
rtn = geteuid();
sprintf(str,"euid = %d",rtn);
//rtn = log_progress(str);
while (1)
{
//rtn = log_progress("5");
rtn =main_loop();
//rtn = log_progress("6");
}
exit(0);
}
void __pmac register_backlight_controller(struct backlight_controller *ctrler,
void *data, char *type)
{
struct device_node* bk_node;
char *prop;
int valid = 0;
/* There's already a matching controller, bail out */
if (backlighter != NULL)
return;
bk_node = find_devices("backlight");
#ifdef CONFIG_ADB_PMU
/* Special case for the old PowerBook since I can't test on it */
backlight_autosave = machine_is_compatible("AAPL,3400/2400")
|| machine_is_compatible("AAPL,3500");
if ((backlight_autosave
|| machine_is_compatible("AAPL,PowerBook1998")
|| machine_is_compatible("PowerBook1,1"))
&& !strcmp(type, "pmu"))
valid = 1;
#endif
if (bk_node) {
prop = get_property(bk_node, "backlight-control", NULL);
if (prop && !strncmp(prop, type, strlen(type)))
valid = 1;
}
if (!valid)
return;
backlighter = ctrler;
backlighter_data = data;
if (bk_node && !backlight_autosave)
prop = get_property(bk_node, "bklt", NULL);
else
prop = NULL;
if (prop) {
backlight_level = ((*prop)+1) >> 1;
if (backlight_level > BACKLIGHT_MAX)
backlight_level = BACKLIGHT_MAX;
}
#ifdef CONFIG_ADB_PMU
if (backlight_autosave) {
struct adb_request req;
pmu_request(&req, NULL, 2, 0xd9, 0);
while (!req.complete)
pmu_poll();
backlight_level = req.reply[0] >> 4;
}
#endif
acquire_console_sem();
if (!backlighter->set_enable(1, backlight_level, data))
backlight_enabled = 1;
release_console_sem();
printk(KERN_INFO "Registered \"%s\" backlight controller,"
"level: %d/15\n", type, backlight_level);
}
int __init
find_via_cuda(void)
{
int err;
struct adb_request req;
if (vias != 0)
return 1;
vias = find_devices("via-cuda");
if (vias == 0)
return 0;
if (vias->next != 0)
printk(KERN_WARNING "Warning: only using 1st via-cuda\n");
#if 0
{ int i;
printk("find_via_cuda: node = %p, addrs =", vias->node);
for (i = 0; i < vias->n_addrs; ++i)
printk(" %x(%x)", vias->addrs[i].address, vias->addrs[i].size);
printk(", intrs =");
for (i = 0; i < vias->n_intrs; ++i)
printk(" %x", vias->intrs[i].line);
printk("\n"); }
#endif
if (vias->n_addrs != 1 || vias->n_intrs != 1) {
printk(KERN_ERR "via-cuda: expecting 1 address (%d) and 1 interrupt (%d)\n",
vias->n_addrs, vias->n_intrs);
if (vias->n_addrs < 1 || vias->n_intrs < 1)
return 0;
}
via = ioremap(vias->addrs->address, 0x2000);
cuda_state = idle;
sys_ctrler = SYS_CTRLER_CUDA;
err = cuda_init_via();
if (err) {
printk(KERN_ERR "cuda_init_via() failed\n");
via = NULL;
return 0;
}
/* Clear and enable interrupts, but only on PPC. On 68K it's done */
/* for us by the main VIA driver in arch/m68k/mac/via.c */
#ifndef CONFIG_MAC
out_8(&via[IFR], 0x7f); /* clear interrupts by writing 1s */
out_8(&via[IER], IER_SET|SR_INT); /* enable interrupt from SR */
#endif
/* enable autopoll */
cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, 1);
while (!req.complete)
cuda_poll();
return 1;
}
int main(int argc, char *argv[])
{
struct device_info dev[16];
int i, opt, num, quiet = 0, mode = HCI;
while ((opt = getopt_long(argc, argv, "+01qh", main_options, NULL)) != -1) {
switch (opt) {
case '0':
mode = HCI;
break;
case '1':
mode = HID;
break;
case 'q':
quiet = 1;
break;
case 'h':
usage();
exit(0);
default:
exit(0);
}
}
argc -= optind;
argv += optind;
optind = 0;
usb_init();
num = find_devices(mode, dev, sizeof(dev) / sizeof(dev[0]));
if (num <= 0) {
if (!quiet)
fprintf(stderr, "No devices in %s mode found\n",
mode ? "HCI" : "HID");
exit(1);
}
for (i = 0; i < num; i++) {
struct device_id *id = dev[i].id;
if (!quiet)
printf("Switching device %04x:%04x to %s mode ",
id->vendor, id->product, mode ? "HID" : "HCI");
fflush(stdout);
if (id->func(&dev[i]) < 0) {
if (!quiet)
printf("failed (%s)\n", strerror(errno));
} else {
if (!quiet)
printf("was successful\n");
}
}
return 0;
}
int simplehal_supported(void)
{
if (!connect_hal()) {
return 0;
} else {
find_devices();
return 1;
}
}
void device_poll_thread() {
adb_thread_setname("Device Poll");
D("Created device thread");
while (true) {
find_devices();
std::this_thread::sleep_for(1s);
}
}
/* Fill the passed apm_info struct. */
int simplehal_read(int battery, apm_info *info)
{
char *device;
int i;
/* Allow a battery that was not present before to appear. */
if (battery > num_batteries)
find_devices();
info->battery_flags = 0;
info->using_minutes = 0;
info->ac_line_status = 0;
for (i = 0 ; i < num_ac_adapters && !info->ac_line_status ; i++)
info->ac_line_status = (get_hal_bool(ac_adapters[i], "ac_adapter.present", 0) == 1);
if (battery > num_batteries) {
info->battery_percentage = 0;
info->battery_time = 0;
info->battery_status = BATTERY_STATUS_ABSENT;
return 0;
} else {
device = batteries[battery-1];
}
if (get_hal_bool(device, "battery.present", 0) != 1) {
info->battery_percentage = 0;
info->battery_time = 0;
info->battery_status = BATTERY_STATUS_ABSENT;
return 0;
}
/* remaining_time and charge_level.percentage are not a mandatory
* keys, so if not present, -1 will be returned */
info->battery_time = get_hal_int(device, "battery.remaining_time", 1);
info->battery_percentage = get_hal_int(device, "battery.charge_level.percentage", 1);
if (get_hal_bool(device, "battery.rechargeable.is_discharging", 0) == 1) {
info->battery_status = BATTERY_STATUS_CHARGING;
/* charge_level.warning and charge_level.low are not
* required to be available; this is good enough */
if (info->battery_percentage < 1)
info->battery_status = BATTERY_STATUS_CRITICAL;
else if (info->battery_percentage < 10)
info->battery_status = BATTERY_STATUS_LOW;
} else if (info->ac_line_status &&
get_hal_bool(device, "battery.rechargeable.is_charging", 0) == 1) {
info->battery_status = BATTERY_STATUS_CHARGING;
info->battery_flags = info->battery_flags | BATTERY_FLAGS_CHARGING;
} else if (info->ac_line_status) {
/* Must be fully charged. */
info->battery_status = BATTERY_STATUS_HIGH;
} else {
fprintf(stderr, "unknown battery state\n");
}
return 0;
}
/**
* Scan the usb device that have given vendor and product id.
* @return positive number of devices connected.<br>-1 on failure
**/
int scan()
{
devices = find_devices(0x0403,0x6001);
if( devices.empty() ) return -1;
scanned = true;
retrieved = false;
return devices.size();
}
void
scsi_curio_dbdma_init(int unit)
{
device_node_t *curio;
scsi_curio_dbdma_commands = dbdma_alloc(2);
curio = find_devices("53c94");
curio_chan = (dbdma_regmap_t *) POWERMAC_IO(curio->addrs[1].address);
}
unsigned char *
find_property(const char *device, const char *propname, unsigned long *size)
{
device_node_t *node;
if ((node = find_devices(device)) == NULL)
return NULL;
return get_property(node, propname, size);
}
/*
* Calibrate the decrementer register using VIA timer 1.
* This is used both on powermacs and CHRP machines.
*/
__initfunc(int via_calibrate_decr(void))
{
struct device_node *vias;
volatile unsigned char *via;
int count = VIA_TIMER_FREQ_6 / HZ;
unsigned int dstart, dend;
vias = find_devices("via-cuda");
if (vias == 0)
vias = find_devices("via-pmu");
if (vias == 0)
vias = find_devices("via");
if (vias == 0 || vias->n_addrs == 0)
return 0;
via = (volatile unsigned char *)
ioremap(vias->addrs[0].address, vias->addrs[0].size);
/* set timer 1 for continuous interrupts */
out_8(&via[ACR], (via[ACR] & ~T1MODE) | T1MODE_CONT);
/* set the counter to a small value */
out_8(&via[T1CH], 2);
/* set the latch to `count' */
out_8(&via[T1LL], count);
out_8(&via[T1LH], count >> 8);
/* wait until it hits 0 */
while ((in_8(&via[IFR]) & T1_INT) == 0)
;
dstart = get_dec();
/* clear the interrupt & wait until it hits 0 again */
in_8(&via[T1CL]);
while ((in_8(&via[IFR]) & T1_INT) == 0)
;
dend = get_dec();
decrementer_count = (dstart - dend) / 6;
count_period_num = 60;
count_period_den = decrementer_count * 6 * HZ / 100000;
printk(KERN_INFO "via_calibrate_decr: decrementer_count = %u (%u ticks)\n",
decrementer_count, dstart - dend);
return 1;
}
int main(int argc, char *argv[])
{
struct device_info dev[16];
int i, opt, num, quiet = 0;
while ((opt = getopt_long(argc, argv, "+qh", main_options, NULL)) != -1) {
switch (opt) {
case 'q':
quiet = 1;
break;
case 'h':
usage();
exit(0);
default:
exit(0);
}
}
argc -= optind;
argv += optind;
optind = 0;
usb_init();
num = find_devices(dev, sizeof(dev) / sizeof(dev[0]));
if (num <= 0) {
if (!quiet)
fprintf(stderr, "No Babel devices found\n");
exit(1);
}
for (i = 0; i < num; i++) {
struct device_id *id = dev[i].id;
int err;
if (!quiet)
printf("Switching device %04x:%04x ",
id->vendor, id->product);
fflush(stdout);
err = id->func(&dev[i], argc, argv);
if (err < 0) {
if (!quiet)
printf("failed (%s)\n", strerror(-err));
} else {
if (!quiet)
printf("was successful\n");
}
}
return 0;
}
int main(int argc, char** argv)
{
std::vector<struct usb_device *> devices;
devices = find_devices(0x0403,0x6001);
if (devices.empty()) {
std::cout << "not found!!!" << std::endl;
return -1;
}
std::cout << devices.size() << " device(s) found." << std::endl;
int ret_val=0;
for( unsigned int i=0; i<devices.size(); i++ )
{
std::cout << std::endl;
std::cout << "Device #" << i << std::endl;
struct usb_device *dev = devices[i];
usb_dev_handle *h = usb_open(dev);
if( h < 0 ) {
std::cerr << "failed to open usb device." << std::endl;
std::cerr << "do with sudo." << std::endl;
}
char buff[128];
int n;
n = usb_get_string_simple(h, dev->descriptor.iManufacturer, buff, 128);
if (n < 0) {
std::cerr << "something is going wrong. do it again with sudo." << std::endl;
ret_val = -1;
continue;
}
std::cout << " Manufacturer : " << std::string(buff) << std::endl;
n = usb_get_string_simple(h, dev->descriptor.iProduct, buff, 128);
if (n < 0) {
std::cerr << "something is going wrong. do it again with sudo." << std::endl;
ret_val = -1;
continue;
}
std::cout << " Product : " << std::string(buff) << std::endl;
n = usb_get_string_simple(h, dev->descriptor.iSerialNumber, buff, 128);
if (n < 0) {
std::cerr << "something is going wrong. do it again with sudo." << std::endl;
ret_val = -1;
continue;
}
std::cout << " Serial Number: " << std::string(buff) << std::endl;
}
return ret_val;
}
int pmac_has_backlight_type(const char *type)
{
struct device_node* bk_node = find_devices("backlight");
if (bk_node) {
const char *prop = get_property(bk_node,
"backlight-control", NULL);
if (prop && strncmp(prop, type, strlen(type)) == 0)
return 1;
}
return 0;
}
int
chips_probe(caddr_t addr)
{
int i;
for (i = 0; chips_names[i]; i++)
if (chips_node = find_devices(chips_names[i])) {
regBase = regBasePhys = (volatile unsigned char *)
chips_node->addrs[0].address + CHIPS_REG_OFFSET;
return 1;
}
return 0;
}
static int __init pmac_declare_of_platform_devices(void)
{
struct device_node *np;
np = find_devices("u3");
if (np) {
for (np = np->child; np != NULL; np = np->sibling)
if (strncmp(np->name, "i2c", 3) == 0) {
of_platform_device_create(np, "u3-i2c");
break;
}
}
return 0;
}
/**
* vio_bus_init: - Initialize the virtual IO bus
*/
static int __init vio_bus_init(void)
{
int err;
struct device_node *node_vroot;
#ifdef CONFIG_PPC_ISERIES
if (firmware_has_feature(FW_FEATURE_ISERIES)) {
iommu_vio_init();
vio_bus_device.iommu_table = &vio_iommu_table;
iSeries_vio_dev = &vio_bus_device.dev;
}
#endif
err = bus_register(&vio_bus_type);
if (err) {
printk(KERN_ERR "failed to register VIO bus\n");
return err;
}
/*
* The fake parent of all vio devices, just to give us
* a nice directory
*/
err = device_register(&vio_bus_device.dev);
if (err) {
printk(KERN_WARNING "%s: device_register returned %i\n",
__FUNCTION__, err);
return err;
}
node_vroot = find_devices("vdevice");
if (node_vroot) {
struct device_node *of_node;
/*
* Create struct vio_devices for each virtual device in
* the device tree. Drivers will associate with them later.
*/
for (of_node = node_vroot->child; of_node != NULL;
of_node = of_node->sibling) {
printk(KERN_DEBUG "%s: processing %p\n",
__FUNCTION__, of_node);
vio_register_device_node(of_node);
}
}
return 0;
}
int __init
tas_init(int driver_id, const char *driver_name)
{
u32* paddr;
printk(KERN_INFO "tas driver [%s])\n", driver_name);
tas_node = find_devices("deq");
if (tas_node == NULL)
return -ENODEV;
paddr = (u32 *)get_property(tas_node, "i2c-address", NULL);
if (paddr) {
tas_i2c_address = (*paddr) >> 1;
printk(KERN_INFO "using i2c address: 0x%x from device-tree\n",
tas_i2c_address);
} else
QVector<CommPortPtr>
Serial::myListCommPorts(QString &err)
{
static const int MAX_DEVICES = 100;
(void) err;
QVector<CommPortPtr> result;
char *devices[MAX_DEVICES];
int devcnt = find_devices(devices, MAX_DEVICES);
if (devcnt == 0)
err = "No serial devices found.";
for (int i = 0; i < devcnt; ++i) {
result.append(CommPortPtr(new Serial(devices[i])));
free(devices[i]);
}
return result;
}
void __pmac pmac_show_cpuinfo(struct seq_file *m)
{
struct device_node *np;
char *pp;
int plen;
char* mbname;
int mbmodel = pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL,
PMAC_MB_INFO_MODEL, 0);
unsigned int mbflags = pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL,
PMAC_MB_INFO_FLAGS, 0);
if (pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL, PMAC_MB_INFO_NAME,
(long)&mbname) != 0)
mbname = "Unknown";
/* find motherboard type */
seq_printf(m, "machine\t\t: ");
np = find_devices("device-tree");
if (np != NULL) {
pp = (char *) get_property(np, "model", NULL);
if (pp != NULL)
seq_printf(m, "%s\n", pp);
else
seq_printf(m, "PowerMac\n");
pp = (char *) get_property(np, "compatible", &plen);
if (pp != NULL) {
seq_printf(m, "motherboard\t:");
while (plen > 0) {
int l = strlen(pp) + 1;
seq_printf(m, " %s", pp);
plen -= l;
pp += l;
}
seq_printf(m, "\n");
}
} else
seq_printf(m, "PowerMac\n");
/* print parsed model */
seq_printf(m, "detected as\t: %d (%s)\n", mbmodel, mbname);
seq_printf(m, "pmac flags\t: %08x\n", mbflags);
/* Indicate newworld */
seq_printf(m, "pmac-generation\t: NewWorld\n");
}
static int __init
init_airport(void)
{
struct device_node* airport_node;
printk(KERN_DEBUG "%s\n", version);
MOD_INC_USE_COUNT;
/* Lookup card in device tree */
airport_node = find_devices("radio");
if (airport_node && !strcmp(airport_node->parent->name, "mac-io"))
airport_dev = airport_attach(airport_node);
MOD_DEC_USE_COUNT;
return airport_dev ? 0 : -ENODEV;
}
int __init
tas_init(int driver_id, const char *driver_name)
{
u32* paddr;
printk(KERN_INFO "tas driver [%s])\n", driver_name);
#ifndef CONFIG_I2C_KEYWEST
request_module("i2c-keywest");
#endif
tas_node = find_devices("deq");
if (tas_node == NULL)
return -ENODEV;
paddr = (u32 *)get_property(tas_node, "i2c-address", NULL);
if (paddr) {
tas_i2c_address = (*paddr) >> 1;
printk(KERN_INFO "using i2c address: 0x%x from device-tree\n",
tas_i2c_address);
} else
int __init
hydra_init(void)
{
struct device_node *np;
np = find_devices("mac-io");
if (np == NULL || np->n_addrs == 0)
return 0;
Hydra = ioremap(np->addrs[0].address, np->addrs[0].size);
printk("Hydra Mac I/O at %x\n", np->addrs[0].address);
out_le32(&Hydra->Feature_Control, (HYDRA_FC_SCC_CELL_EN |
HYDRA_FC_SCSI_CELL_EN |
HYDRA_FC_SCCA_ENABLE |
HYDRA_FC_SCCB_ENABLE |
HYDRA_FC_ARB_BYPASS |
HYDRA_FC_MPIC_ENABLE |
HYDRA_FC_SLOW_SCC_PCLK |
HYDRA_FC_MPIC_IS_MASTER));
return 1;
}
static int enable_all_gpus(Options *op, XConfigPtr config,
XConfigLayoutPtr layout)
{
DevicesPtr pDevices;
int i;
pDevices = find_devices(op);
if (!pDevices) {
nv_error_msg("Unable to determine number of GPUs in system; cannot "
"honor '--enable-all-gpus' option.");
return FALSE;
}
/* free all existing X screens, monitors, devices, and adjacencies */
xconfigFreeScreenList(&config->screens);
xconfigFreeDeviceList(&config->devices);
xconfigFreeMonitorList(&config->monitors);
xconfigFreeAdjacencyList(&layout->adjacencies);
/* add N new screens; this will also add device and monitor sections */
for (i = 0; i < pDevices->nDevices; i++) {
xconfigGenerateAddScreen(config,
pDevices->devices[i].dev.bus,
pDevices->devices[i].dev.domain,
pDevices->devices[i].dev.slot,
pDevices->devices[i].name, i,
"nvidia", "NVIDIA Corporation");
}
free_devices(pDevices);
/* create adjacencies for the layout */
create_adjacencies(op, config, layout);
return TRUE;
} /* enable_all_gpus() */
static int __init
anslcd_init(void)
{
int a;
int retval;
struct device_node* node;
node = find_devices("lcd");
if (!node || !node->parent)
return -ENODEV;
if (strcmp(node->parent->name, "gc"))
return -ENODEV;
anslcd_ptr = ioremap(ANSLCD_ADDR, 0x20);
retval = misc_register(&anslcd_dev);
if(retval < 0){
printk(KERN_INFO "LCD: misc_register failed\n");
iounmap(anslcd_ptr);
return retval;
}
#ifdef DEBUG
printk(KERN_DEBUG "LCD: init\n");
#endif
anslcd_write_byte_ctrl ( 0x38 );
anslcd_write_byte_ctrl ( 0x0c );
anslcd_write_byte_ctrl ( 0x06 );
anslcd_write_byte_ctrl ( 0x01 );
anslcd_write_byte_ctrl ( 0x02 );
for(a=0;a<80;a++) {
anslcd_write_byte_data(anslcd_logo[a]);
}
return 0;
}
int __init
hydra_init(void)
{
struct device_node *np;
struct resource r;
np = find_devices("mac-io");
if (np == NULL || of_address_to_resource(np, 0, &r))
return 0;
Hydra = ioremap(r.start, r.end-r.start);
printk("Hydra Mac I/O at %lx\n", r.start);
printk("Hydra Feature_Control was %x",
in_le32(&Hydra->Feature_Control));
out_le32(&Hydra->Feature_Control, (HYDRA_FC_SCC_CELL_EN |
HYDRA_FC_SCSI_CELL_EN |
HYDRA_FC_SCCA_ENABLE |
HYDRA_FC_SCCB_ENABLE |
HYDRA_FC_ARB_BYPASS |
HYDRA_FC_MPIC_ENABLE |
HYDRA_FC_SLOW_SCC_PCLK |
HYDRA_FC_MPIC_IS_MASTER));
printk(", now %x\n", in_le32(&Hydra->Feature_Control));
return 1;
}
void* device_poll_thread(void* _bridge) {
bridge = (struct dll_bridge *)_bridge;
D("Created device thread\n");
int i = 0;
while(1) {
if (notify_should_kill()) {
D("Cleaned in timer handler\n");
return NULL;
}
if(i % 10 == 0) {
D("In the if-statement");
find_devices();
i = 1;
} else {
i++;
}
adb_sleep_ms(100);
}
return NULL;
}
int __pmac
pmac_show_cpuinfo(struct seq_file *m)
{
struct device_node *np;
char *pp;
int plen;
/* find motherboard type */
seq_printf(m, "machine\t\t: ");
np = find_devices("device-tree");
if (np != NULL) {
pp = (char *) get_property(np, "model", NULL);
if (pp != NULL)
seq_printf(m, "%s\n", pp);
else
seq_printf(m, "PowerMac\n");
pp = (char *) get_property(np, "compatible", &plen);
if (pp != NULL) {
seq_printf(m, "motherboard\t:");
while (plen > 0) {
int l = strlen(pp) + 1;
seq_printf(m, " %s", pp);
plen -= l;
pp += l;
}
seq_printf(m, "\n");
}
} else
seq_printf(m, "PowerMac\n");
/* find l2 cache info */
np = find_devices("l2-cache");
if (np == 0)
np = find_type_devices("cache");
if (np != 0) {
unsigned int *ic = (unsigned int *)
get_property(np, "i-cache-size", NULL);
unsigned int *dc = (unsigned int *)
get_property(np, "d-cache-size", NULL);
seq_printf(m, "L2 cache\t:");
has_l2cache = 1;
if (get_property(np, "cache-unified", NULL) != 0 && dc) {
seq_printf(m, " %dK unified", *dc / 1024);
} else {
if (ic)
seq_printf(m, " %dK instruction", *ic / 1024);
if (dc)
seq_printf(m, "%s %dK data",
(ic? " +": ""), *dc / 1024);
}
pp = get_property(np, "ram-type", NULL);
if (pp)
seq_printf(m, " %s", pp);
seq_printf(m, "\n");
}
/* find ram info */
np = find_devices("memory");
if (np != 0) {
int n;
struct reg_property *reg = (struct reg_property *)
get_property(np, "reg", &n);
if (reg != 0) {
unsigned long total = 0;
for (n /= sizeof(struct reg_property); n > 0; --n)
total += (reg++)->size;
seq_printf(m, "memory\t\t: %luMB\n", total >> 20);
}
__initfunc(void
pmac_pic_init(void))
{
int i;
struct device_node *irqctrler;
volatile struct pmac_irq_hw *addr;
int second_irq;
/* We first try to detect Apple's new Core99 chipset, since mac-io
* is quite different on those machines and contains an IBM MPIC2.
*/
irqctrler = find_type_devices("open-pic");
if (irqctrler != NULL) {
printk("PowerMac using OpenPIC irq controller\n");
if (irqctrler->n_addrs > 0) {
#ifdef CONFIG_XMON
struct device_node* pswitch;
#endif /* CONFIG_XMON */
OpenPIC = (volatile struct OpenPIC *)
ioremap(irqctrler->addrs[0].address,
irqctrler->addrs[0].size);
for ( i = 0 ; i < NR_IRQS ; i++ ) {
irq_desc[i].ctl = &pmac_open_pic;
irq_desc[i].level = 0;
}
openpic_init(1);
has_openpic = 1;
#ifdef CONFIG_XMON
pswitch = find_devices("programmer-switch");
if (pswitch && pswitch->n_intrs)
request_irq(pswitch->intrs[0].line, xmon_irq, 0,
"NMI - XMON", 0);
#endif /* CONFIG_XMON */
return;
}
irqctrler = NULL;
}
/*
* G3 powermacs and 1999 G3 PowerBooks have 64 interrupts,
* 1998 G3 Series PowerBooks have 128,
* other powermacs have 32.
* The combo ethernet/modem card for the Powerstar powerbooks
* (2400/3400/3500, ohare based) has a second ohare chip
* effectively making a total of 64.
*/
max_irqs = max_real_irqs = 32;
irqctrler = find_devices("mac-io");
if (irqctrler)
{
max_real_irqs = 64;
if (irqctrler->next)
max_irqs = 128;
else
max_irqs = 64;
}
for ( i = 0; i < max_real_irqs ; i++ )
irq_desc[i].ctl = &pmac_pic;
/* get addresses of first controller */
if (irqctrler) {
if (irqctrler->n_addrs > 0) {
addr = ioremap(irqctrler->addrs[0].address, 0x40);
addr += 2;
for (i = 0; i < 2; ++i, --addr)
pmac_irq_hw[i] = addr;
}
/* get addresses of second controller */
irqctrler = irqctrler->next;
if (irqctrler && irqctrler->n_addrs > 0) {
addr = ioremap(irqctrler->addrs[0].address, 0x40);
addr += 2;
for (i = 2; i < 4; ++i, --addr)
pmac_irq_hw[i] = addr;
}
}
/* PowerBooks 3400 and 3500 can have a second controller in a second
ohare chip, on the combo ethernet/modem card */
if (machine_is_compatible("AAPL,3400/2400")
|| machine_is_compatible("AAPL,3500"))
enable_second_ohare();
/* disable all interrupts in all controllers */
for (i = 0; i * 32 < max_irqs; ++i)
out_le32(&pmac_irq_hw[i]->enable, 0);
/* get interrupt line of secondary interrupt controller */
if (irqctrler) {
second_irq = irqctrler->intrs[0].line;
printk(KERN_INFO "irq: secondary controller on irq %d\n",
(int)second_irq);
if (device_is_compatible(irqctrler, "gatwick"))
pmac_fix_gatwick_interrupts(irqctrler, max_real_irqs);
request_irq( second_irq, gatwick_action, SA_INTERRUPT,
"interrupt cascade", 0 );
}
for (i = max_real_irqs; i < max_irqs; i++)
irq_desc[i].ctl = &gatwick_pic;
printk("System has %d possible interrupts\n", max_irqs);
if (max_irqs != max_real_irqs)
printk(KERN_DEBUG "%d interrupts on main controller\n",
max_real_irqs);
#ifdef CONFIG_XMON
request_irq(20, xmon_irq, 0, "NMI - XMON", 0);
#endif /* CONFIG_XMON */
}