ppc64: Use arch/powerpc/platforms/powermac for powermac build.
This switches the ARCH=ppc64 build to use arch/powerpc/platforms/powermac instead of arch/ppc64/kernel/pmac*, and deletes the latter set of files. Signed-off-by: Paul Mackerras <paulus@samba.org>
This commit is contained in:
parent
35499c0195
commit
8342894475
|
@ -1,5 +1,9 @@
|
|||
ifeq ($(CONFIG_PPC_MERGE),y)
|
||||
obj-$(CONFIG_PPC_PMAC) += powermac/
|
||||
else
|
||||
ifeq ($(CONFIG_PPC64),y)
|
||||
obj-$(CONFIG_PPC_PMAC) += powermac/
|
||||
endif
|
||||
endif
|
||||
obj-$(CONFIG_4xx) += 4xx/
|
||||
obj-$(CONFIG_85xx) += 85xx/
|
||||
|
|
|
@ -56,11 +56,7 @@ obj-$(CONFIG_HVCS) += hvcserver.o
|
|||
obj-$(CONFIG_IBMVIO) += vio.o
|
||||
obj-$(CONFIG_XICS) += xics.o
|
||||
|
||||
ifneq ($(CONFIG_PPC_MERGE),y)
|
||||
obj-$(CONFIG_PPC_PMAC) += pmac_setup.o pmac_feature.o pmac_pci.o \
|
||||
pmac_time.o pmac_nvram.o pmac_low_i2c.o \
|
||||
udbg_scc.o
|
||||
endif
|
||||
obj-$(CONFIG_PPC_PMAC) += udbg_scc.o
|
||||
|
||||
obj-$(CONFIG_PPC_MAPLE) += maple_setup.o maple_pci.o maple_time.o \
|
||||
udbg_16550.o
|
||||
|
@ -68,9 +64,7 @@ obj-$(CONFIG_PPC_MAPLE) += maple_setup.o maple_pci.o maple_time.o \
|
|||
obj-$(CONFIG_U3_DART) += u3_iommu.o
|
||||
|
||||
ifdef CONFIG_SMP
|
||||
ifneq ($(CONFIG_PPC_MERGE),y)
|
||||
obj-$(CONFIG_PPC_PMAC) += pmac_smp.o smp-tbsync.o
|
||||
endif
|
||||
obj-$(CONFIG_PPC_PMAC) += smp-tbsync.o
|
||||
obj-$(CONFIG_PPC_MAPLE) += smp-tbsync.o
|
||||
endif
|
||||
|
||||
|
|
|
@ -1,31 +0,0 @@
|
|||
#ifndef __PMAC_H__
|
||||
#define __PMAC_H__
|
||||
|
||||
#include <linux/pci.h>
|
||||
#include <linux/ide.h>
|
||||
|
||||
/*
|
||||
* Declaration for the various functions exported by the
|
||||
* pmac_* files. Mostly for use by pmac_setup
|
||||
*/
|
||||
|
||||
extern unsigned long pmac_get_boot_time(void);
|
||||
extern void pmac_get_rtc_time(struct rtc_time *tm);
|
||||
extern int pmac_set_rtc_time(struct rtc_time *tm);
|
||||
extern void pmac_read_rtc_time(void);
|
||||
extern void pmac_calibrate_decr(void);
|
||||
|
||||
extern void pmac_pcibios_fixup(void);
|
||||
extern void pmac_pci_init(void);
|
||||
extern void pmac_setup_pci_dma(void);
|
||||
extern void pmac_check_ht_link(void);
|
||||
|
||||
extern void pmac_setup_smp(void);
|
||||
|
||||
extern unsigned long pmac_ide_get_base(int index);
|
||||
extern void pmac_ide_init_hwif_ports(hw_regs_t *hw,
|
||||
unsigned long data_port, unsigned long ctrl_port, int *irq);
|
||||
|
||||
extern void pmac_nvram_init(void);
|
||||
|
||||
#endif /* __PMAC_H__ */
|
|
@ -1,767 +0,0 @@
|
|||
/*
|
||||
* arch/ppc/platforms/pmac_feature.c
|
||||
*
|
||||
* Copyright (C) 1996-2001 Paul Mackerras (paulus@cs.anu.edu.au)
|
||||
* Ben. Herrenschmidt (benh@kernel.crashing.org)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* TODO:
|
||||
*
|
||||
* - Replace mdelay with some schedule loop if possible
|
||||
* - Shorten some obfuscated delays on some routines (like modem
|
||||
* power)
|
||||
* - Refcount some clocks (see darwin)
|
||||
* - Split split split...
|
||||
*
|
||||
*/
|
||||
#include <linux/config.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/adb.h>
|
||||
#include <linux/pmu.h>
|
||||
#include <linux/ioport.h>
|
||||
#include <linux/pci.h>
|
||||
#include <asm/sections.h>
|
||||
#include <asm/errno.h>
|
||||
#include <asm/keylargo.h>
|
||||
#include <asm/uninorth.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/pmac_feature.h>
|
||||
#include <asm/dbdma.h>
|
||||
#include <asm/pci-bridge.h>
|
||||
#include <asm/pmac_low_i2c.h>
|
||||
|
||||
#undef DEBUG_FEATURE
|
||||
|
||||
#ifdef DEBUG_FEATURE
|
||||
#define DBG(fmt...) printk(KERN_DEBUG fmt)
|
||||
#else
|
||||
#define DBG(fmt...)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* We use a single global lock to protect accesses. Each driver has
|
||||
* to take care of its own locking
|
||||
*/
|
||||
static DEFINE_SPINLOCK(feature_lock);
|
||||
|
||||
#define LOCK(flags) spin_lock_irqsave(&feature_lock, flags);
|
||||
#define UNLOCK(flags) spin_unlock_irqrestore(&feature_lock, flags);
|
||||
|
||||
|
||||
/*
|
||||
* Instance of some macio stuffs
|
||||
*/
|
||||
struct macio_chip macio_chips[MAX_MACIO_CHIPS] ;
|
||||
|
||||
struct macio_chip* macio_find(struct device_node* child, int type)
|
||||
{
|
||||
while(child) {
|
||||
int i;
|
||||
|
||||
for (i=0; i < MAX_MACIO_CHIPS && macio_chips[i].of_node; i++)
|
||||
if (child == macio_chips[i].of_node &&
|
||||
(!type || macio_chips[i].type == type))
|
||||
return &macio_chips[i];
|
||||
child = child->parent;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(macio_find);
|
||||
|
||||
static const char* macio_names[] =
|
||||
{
|
||||
"Unknown",
|
||||
"Grand Central",
|
||||
"OHare",
|
||||
"OHareII",
|
||||
"Heathrow",
|
||||
"Gatwick",
|
||||
"Paddington",
|
||||
"Keylargo",
|
||||
"Pangea",
|
||||
"Intrepid",
|
||||
"K2"
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Uninorth reg. access. Note that Uni-N regs are big endian
|
||||
*/
|
||||
|
||||
#define UN_REG(r) (uninorth_base + ((r) >> 2))
|
||||
#define UN_IN(r) (in_be32(UN_REG(r)))
|
||||
#define UN_OUT(r,v) (out_be32(UN_REG(r), (v)))
|
||||
#define UN_BIS(r,v) (UN_OUT((r), UN_IN(r) | (v)))
|
||||
#define UN_BIC(r,v) (UN_OUT((r), UN_IN(r) & ~(v)))
|
||||
|
||||
static struct device_node* uninorth_node;
|
||||
static u32* uninorth_base;
|
||||
static u32 uninorth_rev;
|
||||
static void *u3_ht;
|
||||
|
||||
extern struct device_node *k2_skiplist[2];
|
||||
|
||||
/*
|
||||
* For each motherboard family, we have a table of functions pointers
|
||||
* that handle the various features.
|
||||
*/
|
||||
|
||||
typedef long (*feature_call)(struct device_node* node, long param, long value);
|
||||
|
||||
struct feature_table_entry {
|
||||
unsigned int selector;
|
||||
feature_call function;
|
||||
};
|
||||
|
||||
struct pmac_mb_def
|
||||
{
|
||||
const char* model_string;
|
||||
const char* model_name;
|
||||
int model_id;
|
||||
struct feature_table_entry* features;
|
||||
unsigned long board_flags;
|
||||
};
|
||||
static struct pmac_mb_def pmac_mb;
|
||||
|
||||
/*
|
||||
* Here are the chip specific feature functions
|
||||
*/
|
||||
|
||||
|
||||
static long g5_read_gpio(struct device_node* node, long param, long value)
|
||||
{
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
|
||||
return MACIO_IN8(param);
|
||||
}
|
||||
|
||||
|
||||
static long g5_write_gpio(struct device_node* node, long param, long value)
|
||||
{
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
|
||||
MACIO_OUT8(param, (u8)(value & 0xff));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long g5_gmac_enable(struct device_node* node, long param, long value)
|
||||
{
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
unsigned long flags;
|
||||
|
||||
if (node == NULL)
|
||||
return -ENODEV;
|
||||
|
||||
LOCK(flags);
|
||||
if (value) {
|
||||
MACIO_BIS(KEYLARGO_FCR1, K2_FCR1_GMAC_CLK_ENABLE);
|
||||
mb();
|
||||
k2_skiplist[0] = NULL;
|
||||
} else {
|
||||
k2_skiplist[0] = node;
|
||||
mb();
|
||||
MACIO_BIC(KEYLARGO_FCR1, K2_FCR1_GMAC_CLK_ENABLE);
|
||||
}
|
||||
|
||||
UNLOCK(flags);
|
||||
mdelay(1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long g5_fw_enable(struct device_node* node, long param, long value)
|
||||
{
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
unsigned long flags;
|
||||
|
||||
if (node == NULL)
|
||||
return -ENODEV;
|
||||
|
||||
LOCK(flags);
|
||||
if (value) {
|
||||
MACIO_BIS(KEYLARGO_FCR1, K2_FCR1_FW_CLK_ENABLE);
|
||||
mb();
|
||||
k2_skiplist[1] = NULL;
|
||||
} else {
|
||||
k2_skiplist[1] = node;
|
||||
mb();
|
||||
MACIO_BIC(KEYLARGO_FCR1, K2_FCR1_FW_CLK_ENABLE);
|
||||
}
|
||||
|
||||
UNLOCK(flags);
|
||||
mdelay(1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long g5_mpic_enable(struct device_node* node, long param, long value)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
if (node->parent == NULL || strcmp(node->parent->name, "u3"))
|
||||
return 0;
|
||||
|
||||
LOCK(flags);
|
||||
UN_BIS(U3_TOGGLE_REG, U3_MPIC_RESET | U3_MPIC_OUTPUT_ENABLE);
|
||||
UNLOCK(flags);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long g5_eth_phy_reset(struct device_node* node, long param, long value)
|
||||
{
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
struct device_node *phy;
|
||||
int need_reset;
|
||||
|
||||
/*
|
||||
* We must not reset the combo PHYs, only the BCM5221 found in
|
||||
* the iMac G5.
|
||||
*/
|
||||
phy = of_get_next_child(node, NULL);
|
||||
if (!phy)
|
||||
return -ENODEV;
|
||||
need_reset = device_is_compatible(phy, "B5221");
|
||||
of_node_put(phy);
|
||||
if (!need_reset)
|
||||
return 0;
|
||||
|
||||
/* PHY reset is GPIO 29, not in device-tree unfortunately */
|
||||
MACIO_OUT8(K2_GPIO_EXTINT_0 + 29,
|
||||
KEYLARGO_GPIO_OUTPUT_ENABLE | KEYLARGO_GPIO_OUTOUT_DATA);
|
||||
/* Thankfully, this is now always called at a time when we can
|
||||
* schedule by sungem.
|
||||
*/
|
||||
msleep(10);
|
||||
MACIO_OUT8(K2_GPIO_EXTINT_0 + 29, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long g5_i2s_enable(struct device_node *node, long param, long value)
|
||||
{
|
||||
/* Very crude implementation for now */
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
unsigned long flags;
|
||||
|
||||
if (value == 0)
|
||||
return 0; /* don't disable yet */
|
||||
|
||||
LOCK(flags);
|
||||
MACIO_BIS(KEYLARGO_FCR3, KL3_CLK45_ENABLE | KL3_CLK49_ENABLE |
|
||||
KL3_I2S0_CLK18_ENABLE);
|
||||
udelay(10);
|
||||
MACIO_BIS(KEYLARGO_FCR1, K2_FCR1_I2S0_CELL_ENABLE |
|
||||
K2_FCR1_I2S0_CLK_ENABLE_BIT | K2_FCR1_I2S0_ENABLE);
|
||||
udelay(10);
|
||||
MACIO_BIC(KEYLARGO_FCR1, K2_FCR1_I2S0_RESET);
|
||||
UNLOCK(flags);
|
||||
udelay(10);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
static long g5_reset_cpu(struct device_node* node, long param, long value)
|
||||
{
|
||||
unsigned int reset_io = 0;
|
||||
unsigned long flags;
|
||||
struct macio_chip* macio;
|
||||
struct device_node* np;
|
||||
|
||||
macio = &macio_chips[0];
|
||||
if (macio->type != macio_keylargo2)
|
||||
return -ENODEV;
|
||||
|
||||
np = find_path_device("/cpus");
|
||||
if (np == NULL)
|
||||
return -ENODEV;
|
||||
for (np = np->child; np != NULL; np = np->sibling) {
|
||||
u32* num = (u32 *)get_property(np, "reg", NULL);
|
||||
u32* rst = (u32 *)get_property(np, "soft-reset", NULL);
|
||||
if (num == NULL || rst == NULL)
|
||||
continue;
|
||||
if (param == *num) {
|
||||
reset_io = *rst;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (np == NULL || reset_io == 0)
|
||||
return -ENODEV;
|
||||
|
||||
LOCK(flags);
|
||||
MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE);
|
||||
(void)MACIO_IN8(reset_io);
|
||||
udelay(1);
|
||||
MACIO_OUT8(reset_io, 0);
|
||||
(void)MACIO_IN8(reset_io);
|
||||
UNLOCK(flags);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* CONFIG_SMP */
|
||||
|
||||
/*
|
||||
* This can be called from pmac_smp so isn't static
|
||||
*
|
||||
* This takes the second CPU off the bus on dual CPU machines
|
||||
* running UP
|
||||
*/
|
||||
void g5_phy_disable_cpu1(void)
|
||||
{
|
||||
UN_OUT(U3_API_PHY_CONFIG_1, 0);
|
||||
}
|
||||
|
||||
static long generic_get_mb_info(struct device_node* node, long param, long value)
|
||||
{
|
||||
switch(param) {
|
||||
case PMAC_MB_INFO_MODEL:
|
||||
return pmac_mb.model_id;
|
||||
case PMAC_MB_INFO_FLAGS:
|
||||
return pmac_mb.board_flags;
|
||||
case PMAC_MB_INFO_NAME:
|
||||
/* hack hack hack... but should work */
|
||||
*((const char **)value) = pmac_mb.model_name;
|
||||
return 0;
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Table definitions
|
||||
*/
|
||||
|
||||
/* Used on any machine
|
||||
*/
|
||||
static struct feature_table_entry any_features[] = {
|
||||
{ PMAC_FTR_GET_MB_INFO, generic_get_mb_info },
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
/* G5 features
|
||||
*/
|
||||
static struct feature_table_entry g5_features[] = {
|
||||
{ PMAC_FTR_GMAC_ENABLE, g5_gmac_enable },
|
||||
{ PMAC_FTR_1394_ENABLE, g5_fw_enable },
|
||||
{ PMAC_FTR_ENABLE_MPIC, g5_mpic_enable },
|
||||
{ PMAC_FTR_READ_GPIO, g5_read_gpio },
|
||||
{ PMAC_FTR_WRITE_GPIO, g5_write_gpio },
|
||||
{ PMAC_FTR_GMAC_PHY_RESET, g5_eth_phy_reset },
|
||||
{ PMAC_FTR_SOUND_CHIP_ENABLE, g5_i2s_enable },
|
||||
#ifdef CONFIG_SMP
|
||||
{ PMAC_FTR_RESET_CPU, g5_reset_cpu },
|
||||
#endif /* CONFIG_SMP */
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
static struct pmac_mb_def pmac_mb_defs[] = {
|
||||
{ "PowerMac7,2", "PowerMac G5",
|
||||
PMAC_TYPE_POWERMAC_G5, g5_features,
|
||||
0,
|
||||
},
|
||||
{ "PowerMac7,3", "PowerMac G5",
|
||||
PMAC_TYPE_POWERMAC_G5, g5_features,
|
||||
0,
|
||||
},
|
||||
{ "PowerMac8,1", "iMac G5",
|
||||
PMAC_TYPE_IMAC_G5, g5_features,
|
||||
0,
|
||||
},
|
||||
{ "PowerMac9,1", "PowerMac G5",
|
||||
PMAC_TYPE_POWERMAC_G5_U3L, g5_features,
|
||||
0,
|
||||
},
|
||||
{ "RackMac3,1", "XServe G5",
|
||||
PMAC_TYPE_XSERVE_G5, g5_features,
|
||||
0,
|
||||
},
|
||||
};
|
||||
|
||||
/*
|
||||
* The toplevel feature_call callback
|
||||
*/
|
||||
long pmac_do_feature_call(unsigned int selector, ...)
|
||||
{
|
||||
struct device_node* node;
|
||||
long param, value;
|
||||
int i;
|
||||
feature_call func = NULL;
|
||||
va_list args;
|
||||
|
||||
if (pmac_mb.features)
|
||||
for (i=0; pmac_mb.features[i].function; i++)
|
||||
if (pmac_mb.features[i].selector == selector) {
|
||||
func = pmac_mb.features[i].function;
|
||||
break;
|
||||
}
|
||||
if (!func)
|
||||
for (i=0; any_features[i].function; i++)
|
||||
if (any_features[i].selector == selector) {
|
||||
func = any_features[i].function;
|
||||
break;
|
||||
}
|
||||
if (!func)
|
||||
return -ENODEV;
|
||||
|
||||
va_start(args, selector);
|
||||
node = (struct device_node*)va_arg(args, void*);
|
||||
param = va_arg(args, long);
|
||||
value = va_arg(args, long);
|
||||
va_end(args);
|
||||
|
||||
return func(node, param, value);
|
||||
}
|
||||
|
||||
static int __init probe_motherboard(void)
|
||||
{
|
||||
int i;
|
||||
struct macio_chip* macio = &macio_chips[0];
|
||||
const char* model = NULL;
|
||||
struct device_node *dt;
|
||||
|
||||
/* Lookup known motherboard type in device-tree. First try an
|
||||
* exact match on the "model" property, then try a "compatible"
|
||||
* match is none is found.
|
||||
*/
|
||||
dt = find_devices("device-tree");
|
||||
if (dt != NULL)
|
||||
model = (const char *) get_property(dt, "model", NULL);
|
||||
for(i=0; model && i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
|
||||
if (strcmp(model, pmac_mb_defs[i].model_string) == 0) {
|
||||
pmac_mb = pmac_mb_defs[i];
|
||||
goto found;
|
||||
}
|
||||
}
|
||||
for(i=0; i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
|
||||
if (machine_is_compatible(pmac_mb_defs[i].model_string)) {
|
||||
pmac_mb = pmac_mb_defs[i];
|
||||
goto found;
|
||||
}
|
||||
}
|
||||
|
||||
/* Fallback to selection depending on mac-io chip type */
|
||||
switch(macio->type) {
|
||||
case macio_keylargo2:
|
||||
pmac_mb.model_id = PMAC_TYPE_UNKNOWN_K2;
|
||||
pmac_mb.model_name = "Unknown K2-based";
|
||||
pmac_mb.features = g5_features;
|
||||
|
||||
default:
|
||||
return -ENODEV;
|
||||
}
|
||||
found:
|
||||
/* Check for "mobile" machine */
|
||||
if (model && (strncmp(model, "PowerBook", 9) == 0
|
||||
|| strncmp(model, "iBook", 5) == 0))
|
||||
pmac_mb.board_flags |= PMAC_MB_MOBILE;
|
||||
|
||||
|
||||
printk(KERN_INFO "PowerMac motherboard: %s\n", pmac_mb.model_name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Initialize the Core99 UniNorth host bridge and memory controller
|
||||
*/
|
||||
static void __init probe_uninorth(void)
|
||||
{
|
||||
uninorth_node = of_find_node_by_name(NULL, "u3");
|
||||
if (uninorth_node && uninorth_node->n_addrs > 0) {
|
||||
/* Small hack until I figure out if parsing in prom.c is correct. I should
|
||||
* get rid of those pre-parsed junk anyway
|
||||
*/
|
||||
unsigned long address = uninorth_node->addrs[0].address;
|
||||
uninorth_base = ioremap(address, 0x40000);
|
||||
uninorth_rev = in_be32(UN_REG(UNI_N_VERSION));
|
||||
u3_ht = ioremap(address + U3_HT_CONFIG_BASE, 0x1000);
|
||||
} else
|
||||
uninorth_node = NULL;
|
||||
|
||||
if (!uninorth_node)
|
||||
return;
|
||||
|
||||
printk(KERN_INFO "Found U3 memory controller & host bridge, revision: %d\n",
|
||||
uninorth_rev);
|
||||
printk(KERN_INFO "Mapped at 0x%08lx\n", (unsigned long)uninorth_base);
|
||||
|
||||
}
|
||||
|
||||
static void __init probe_one_macio(const char* name, const char* compat, int type)
|
||||
{
|
||||
struct device_node* node;
|
||||
int i;
|
||||
volatile u32* base;
|
||||
u32* revp;
|
||||
|
||||
node = find_devices(name);
|
||||
if (!node || !node->n_addrs)
|
||||
return;
|
||||
if (compat)
|
||||
do {
|
||||
if (device_is_compatible(node, compat))
|
||||
break;
|
||||
node = node->next;
|
||||
} while (node);
|
||||
if (!node)
|
||||
return;
|
||||
for(i=0; i<MAX_MACIO_CHIPS; i++) {
|
||||
if (!macio_chips[i].of_node)
|
||||
break;
|
||||
if (macio_chips[i].of_node == node)
|
||||
return;
|
||||
}
|
||||
if (i >= MAX_MACIO_CHIPS) {
|
||||
printk(KERN_ERR "pmac_feature: Please increase MAX_MACIO_CHIPS !\n");
|
||||
printk(KERN_ERR "pmac_feature: %s skipped\n", node->full_name);
|
||||
return;
|
||||
}
|
||||
base = (volatile u32*)ioremap(node->addrs[0].address, node->addrs[0].size);
|
||||
if (!base) {
|
||||
printk(KERN_ERR "pmac_feature: Can't map mac-io chip !\n");
|
||||
return;
|
||||
}
|
||||
if (type == macio_keylargo) {
|
||||
u32* did = (u32 *)get_property(node, "device-id", NULL);
|
||||
if (*did == 0x00000025)
|
||||
type = macio_pangea;
|
||||
if (*did == 0x0000003e)
|
||||
type = macio_intrepid;
|
||||
}
|
||||
macio_chips[i].of_node = node;
|
||||
macio_chips[i].type = type;
|
||||
macio_chips[i].base = base;
|
||||
macio_chips[i].flags = MACIO_FLAG_SCCB_ON | MACIO_FLAG_SCCB_ON;
|
||||
macio_chips[i].name = macio_names[type];
|
||||
revp = (u32 *)get_property(node, "revision-id", NULL);
|
||||
if (revp)
|
||||
macio_chips[i].rev = *revp;
|
||||
printk(KERN_INFO "Found a %s mac-io controller, rev: %d, mapped at 0x%p\n",
|
||||
macio_names[type], macio_chips[i].rev, macio_chips[i].base);
|
||||
}
|
||||
|
||||
static int __init
|
||||
probe_macios(void)
|
||||
{
|
||||
probe_one_macio("mac-io", "K2-Keylargo", macio_keylargo2);
|
||||
|
||||
macio_chips[0].lbus.index = 0;
|
||||
macio_chips[1].lbus.index = 1;
|
||||
|
||||
return (macio_chips[0].of_node == NULL) ? -ENODEV : 0;
|
||||
}
|
||||
|
||||
static void __init
|
||||
set_initial_features(void)
|
||||
{
|
||||
struct device_node *np;
|
||||
|
||||
if (macio_chips[0].type == macio_keylargo2) {
|
||||
#ifndef CONFIG_SMP
|
||||
/* On SMP machines running UP, we have the second CPU eating
|
||||
* bus cycles. We need to take it off the bus. This is done
|
||||
* from pmac_smp for SMP kernels running on one CPU
|
||||
*/
|
||||
np = of_find_node_by_type(NULL, "cpu");
|
||||
if (np != NULL)
|
||||
np = of_find_node_by_type(np, "cpu");
|
||||
if (np != NULL) {
|
||||
g5_phy_disable_cpu1();
|
||||
of_node_put(np);
|
||||
}
|
||||
#endif /* CONFIG_SMP */
|
||||
/* Enable GMAC for now for PCI probing. It will be disabled
|
||||
* later on after PCI probe
|
||||
*/
|
||||
np = of_find_node_by_name(NULL, "ethernet");
|
||||
while(np) {
|
||||
if (device_is_compatible(np, "K2-GMAC"))
|
||||
g5_gmac_enable(np, 0, 1);
|
||||
np = of_find_node_by_name(np, "ethernet");
|
||||
}
|
||||
|
||||
/* Enable FW before PCI probe. Will be disabled later on
|
||||
* Note: We should have a batter way to check that we are
|
||||
* dealing with uninorth internal cell and not a PCI cell
|
||||
* on the external PCI. The code below works though.
|
||||
*/
|
||||
np = of_find_node_by_name(NULL, "firewire");
|
||||
while(np) {
|
||||
if (device_is_compatible(np, "pci106b,5811")) {
|
||||
macio_chips[0].flags |= MACIO_FLAG_FW_SUPPORTED;
|
||||
g5_fw_enable(np, 0, 1);
|
||||
}
|
||||
np = of_find_node_by_name(np, "firewire");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void __init
|
||||
pmac_feature_init(void)
|
||||
{
|
||||
/* Detect the UniNorth memory controller */
|
||||
probe_uninorth();
|
||||
|
||||
/* Probe mac-io controllers */
|
||||
if (probe_macios()) {
|
||||
printk(KERN_WARNING "No mac-io chip found\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Setup low-level i2c stuffs */
|
||||
pmac_init_low_i2c();
|
||||
|
||||
/* Probe machine type */
|
||||
if (probe_motherboard())
|
||||
printk(KERN_WARNING "Unknown PowerMac !\n");
|
||||
|
||||
/* Set some initial features (turn off some chips that will
|
||||
* be later turned on)
|
||||
*/
|
||||
set_initial_features();
|
||||
}
|
||||
|
||||
int __init pmac_feature_late_init(void)
|
||||
{
|
||||
#if 0
|
||||
struct device_node* np;
|
||||
|
||||
/* Request some resources late */
|
||||
if (uninorth_node)
|
||||
request_OF_resource(uninorth_node, 0, NULL);
|
||||
np = find_devices("hammerhead");
|
||||
if (np)
|
||||
request_OF_resource(np, 0, NULL);
|
||||
np = find_devices("interrupt-controller");
|
||||
if (np)
|
||||
request_OF_resource(np, 0, NULL);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
device_initcall(pmac_feature_late_init);
|
||||
|
||||
#if 0
|
||||
static void dump_HT_speeds(char *name, u32 cfg, u32 frq)
|
||||
{
|
||||
int freqs[16] = { 200,300,400,500,600,800,1000,0,0,0,0,0,0,0,0,0 };
|
||||
int bits[8] = { 8,16,0,32,2,4,0,0 };
|
||||
int freq = (frq >> 8) & 0xf;
|
||||
|
||||
if (freqs[freq] == 0)
|
||||
printk("%s: Unknown HT link frequency %x\n", name, freq);
|
||||
else
|
||||
printk("%s: %d MHz on main link, (%d in / %d out) bits width\n",
|
||||
name, freqs[freq],
|
||||
bits[(cfg >> 28) & 0x7], bits[(cfg >> 24) & 0x7]);
|
||||
}
|
||||
#endif
|
||||
|
||||
void __init pmac_check_ht_link(void)
|
||||
{
|
||||
#if 0 /* Disabled for now */
|
||||
u32 ufreq, freq, ucfg, cfg;
|
||||
struct device_node *pcix_node;
|
||||
struct pci_dn *pdn;
|
||||
u8 px_bus, px_devfn;
|
||||
struct pci_controller *px_hose;
|
||||
|
||||
(void)in_be32(u3_ht + U3_HT_LINK_COMMAND);
|
||||
ucfg = cfg = in_be32(u3_ht + U3_HT_LINK_CONFIG);
|
||||
ufreq = freq = in_be32(u3_ht + U3_HT_LINK_FREQ);
|
||||
dump_HT_speeds("U3 HyperTransport", cfg, freq);
|
||||
|
||||
pcix_node = of_find_compatible_node(NULL, "pci", "pci-x");
|
||||
if (pcix_node == NULL) {
|
||||
printk("No PCI-X bridge found\n");
|
||||
return;
|
||||
}
|
||||
pdn = pcix_node->data;
|
||||
px_hose = pdn->phb;
|
||||
px_bus = pdn->busno;
|
||||
px_devfn = pdn->devfn;
|
||||
|
||||
early_read_config_dword(px_hose, px_bus, px_devfn, 0xc4, &cfg);
|
||||
early_read_config_dword(px_hose, px_bus, px_devfn, 0xcc, &freq);
|
||||
dump_HT_speeds("PCI-X HT Uplink", cfg, freq);
|
||||
early_read_config_dword(px_hose, px_bus, px_devfn, 0xc8, &cfg);
|
||||
early_read_config_dword(px_hose, px_bus, px_devfn, 0xd0, &freq);
|
||||
dump_HT_speeds("PCI-X HT Downlink", cfg, freq);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* Early video resume hook
|
||||
*/
|
||||
|
||||
static void (*pmac_early_vresume_proc)(void *data);
|
||||
static void *pmac_early_vresume_data;
|
||||
|
||||
void pmac_set_early_video_resume(void (*proc)(void *data), void *data)
|
||||
{
|
||||
if (_machine != _MACH_Pmac)
|
||||
return;
|
||||
preempt_disable();
|
||||
pmac_early_vresume_proc = proc;
|
||||
pmac_early_vresume_data = data;
|
||||
preempt_enable();
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_set_early_video_resume);
|
||||
|
||||
|
||||
/*
|
||||
* AGP related suspend/resume code
|
||||
*/
|
||||
|
||||
static struct pci_dev *pmac_agp_bridge;
|
||||
static int (*pmac_agp_suspend)(struct pci_dev *bridge);
|
||||
static int (*pmac_agp_resume)(struct pci_dev *bridge);
|
||||
|
||||
void pmac_register_agp_pm(struct pci_dev *bridge,
|
||||
int (*suspend)(struct pci_dev *bridge),
|
||||
int (*resume)(struct pci_dev *bridge))
|
||||
{
|
||||
if (suspend || resume) {
|
||||
pmac_agp_bridge = bridge;
|
||||
pmac_agp_suspend = suspend;
|
||||
pmac_agp_resume = resume;
|
||||
return;
|
||||
}
|
||||
if (bridge != pmac_agp_bridge)
|
||||
return;
|
||||
pmac_agp_suspend = pmac_agp_resume = NULL;
|
||||
return;
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_register_agp_pm);
|
||||
|
||||
void pmac_suspend_agp_for_card(struct pci_dev *dev)
|
||||
{
|
||||
if (pmac_agp_bridge == NULL || pmac_agp_suspend == NULL)
|
||||
return;
|
||||
if (pmac_agp_bridge->bus != dev->bus)
|
||||
return;
|
||||
pmac_agp_suspend(pmac_agp_bridge);
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_suspend_agp_for_card);
|
||||
|
||||
void pmac_resume_agp_for_card(struct pci_dev *dev)
|
||||
{
|
||||
if (pmac_agp_bridge == NULL || pmac_agp_resume == NULL)
|
||||
return;
|
||||
if (pmac_agp_bridge->bus != dev->bus)
|
||||
return;
|
||||
pmac_agp_resume(pmac_agp_bridge);
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_resume_agp_for_card);
|
|
@ -1,523 +0,0 @@
|
|||
/*
|
||||
* arch/ppc/platforms/pmac_low_i2c.c
|
||||
*
|
||||
* Copyright (C) 2003 Ben. Herrenschmidt (benh@kernel.crashing.org)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This file contains some low-level i2c access routines that
|
||||
* need to be used by various bits of the PowerMac platform code
|
||||
* at times where the real asynchronous & interrupt driven driver
|
||||
* cannot be used. The API borrows some semantics from the darwin
|
||||
* driver in order to ease the implementation of the platform
|
||||
* properties parser
|
||||
*/
|
||||
|
||||
#undef DEBUG
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/adb.h>
|
||||
#include <linux/pmu.h>
|
||||
#include <asm/keylargo.h>
|
||||
#include <asm/uninorth.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/pmac_low_i2c.h>
|
||||
|
||||
#define MAX_LOW_I2C_HOST 4
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DBG(x...) do {\
|
||||
printk(KERN_DEBUG "KW:" x); \
|
||||
} while(0)
|
||||
#else
|
||||
#define DBG(x...)
|
||||
#endif
|
||||
|
||||
struct low_i2c_host;
|
||||
|
||||
typedef int (*low_i2c_func_t)(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len);
|
||||
|
||||
struct low_i2c_host
|
||||
{
|
||||
struct device_node *np; /* OF device node */
|
||||
struct semaphore mutex; /* Access mutex for use by i2c-keywest */
|
||||
low_i2c_func_t func; /* Access function */
|
||||
unsigned int is_open : 1; /* Poor man's access control */
|
||||
int mode; /* Current mode */
|
||||
int channel; /* Current channel */
|
||||
int num_channels; /* Number of channels */
|
||||
void __iomem *base; /* For keywest-i2c, base address */
|
||||
int bsteps; /* And register stepping */
|
||||
int speed; /* And speed */
|
||||
};
|
||||
|
||||
static struct low_i2c_host low_i2c_hosts[MAX_LOW_I2C_HOST];
|
||||
|
||||
/* No locking is necessary on allocation, we are running way before
|
||||
* anything can race with us
|
||||
*/
|
||||
static struct low_i2c_host *find_low_i2c_host(struct device_node *np)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAX_LOW_I2C_HOST; i++)
|
||||
if (low_i2c_hosts[i].np == np)
|
||||
return &low_i2c_hosts[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* i2c-keywest implementation (UniNorth, U2, U3, Keylargo's)
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Keywest i2c definitions borrowed from drivers/i2c/i2c-keywest.h,
|
||||
* should be moved somewhere in include/asm-ppc/
|
||||
*/
|
||||
/* Register indices */
|
||||
typedef enum {
|
||||
reg_mode = 0,
|
||||
reg_control,
|
||||
reg_status,
|
||||
reg_isr,
|
||||
reg_ier,
|
||||
reg_addr,
|
||||
reg_subaddr,
|
||||
reg_data
|
||||
} reg_t;
|
||||
|
||||
|
||||
/* Mode register */
|
||||
#define KW_I2C_MODE_100KHZ 0x00
|
||||
#define KW_I2C_MODE_50KHZ 0x01
|
||||
#define KW_I2C_MODE_25KHZ 0x02
|
||||
#define KW_I2C_MODE_DUMB 0x00
|
||||
#define KW_I2C_MODE_STANDARD 0x04
|
||||
#define KW_I2C_MODE_STANDARDSUB 0x08
|
||||
#define KW_I2C_MODE_COMBINED 0x0C
|
||||
#define KW_I2C_MODE_MODE_MASK 0x0C
|
||||
#define KW_I2C_MODE_CHAN_MASK 0xF0
|
||||
|
||||
/* Control register */
|
||||
#define KW_I2C_CTL_AAK 0x01
|
||||
#define KW_I2C_CTL_XADDR 0x02
|
||||
#define KW_I2C_CTL_STOP 0x04
|
||||
#define KW_I2C_CTL_START 0x08
|
||||
|
||||
/* Status register */
|
||||
#define KW_I2C_STAT_BUSY 0x01
|
||||
#define KW_I2C_STAT_LAST_AAK 0x02
|
||||
#define KW_I2C_STAT_LAST_RW 0x04
|
||||
#define KW_I2C_STAT_SDA 0x08
|
||||
#define KW_I2C_STAT_SCL 0x10
|
||||
|
||||
/* IER & ISR registers */
|
||||
#define KW_I2C_IRQ_DATA 0x01
|
||||
#define KW_I2C_IRQ_ADDR 0x02
|
||||
#define KW_I2C_IRQ_STOP 0x04
|
||||
#define KW_I2C_IRQ_START 0x08
|
||||
#define KW_I2C_IRQ_MASK 0x0F
|
||||
|
||||
/* State machine states */
|
||||
enum {
|
||||
state_idle,
|
||||
state_addr,
|
||||
state_read,
|
||||
state_write,
|
||||
state_stop,
|
||||
state_dead
|
||||
};
|
||||
|
||||
#define WRONG_STATE(name) do {\
|
||||
printk(KERN_DEBUG "KW: wrong state. Got %s, state: %s (isr: %02x)\n", \
|
||||
name, __kw_state_names[state], isr); \
|
||||
} while(0)
|
||||
|
||||
static const char *__kw_state_names[] = {
|
||||
"state_idle",
|
||||
"state_addr",
|
||||
"state_read",
|
||||
"state_write",
|
||||
"state_stop",
|
||||
"state_dead"
|
||||
};
|
||||
|
||||
static inline u8 __kw_read_reg(struct low_i2c_host *host, reg_t reg)
|
||||
{
|
||||
return readb(host->base + (((unsigned int)reg) << host->bsteps));
|
||||
}
|
||||
|
||||
static inline void __kw_write_reg(struct low_i2c_host *host, reg_t reg, u8 val)
|
||||
{
|
||||
writeb(val, host->base + (((unsigned)reg) << host->bsteps));
|
||||
(void)__kw_read_reg(host, reg_subaddr);
|
||||
}
|
||||
|
||||
#define kw_write_reg(reg, val) __kw_write_reg(host, reg, val)
|
||||
#define kw_read_reg(reg) __kw_read_reg(host, reg)
|
||||
|
||||
|
||||
/* Don't schedule, the g5 fan controller is too
|
||||
* timing sensitive
|
||||
*/
|
||||
static u8 kw_wait_interrupt(struct low_i2c_host* host)
|
||||
{
|
||||
int i, j;
|
||||
u8 isr;
|
||||
|
||||
for (i = 0; i < 100000; i++) {
|
||||
isr = kw_read_reg(reg_isr) & KW_I2C_IRQ_MASK;
|
||||
if (isr != 0)
|
||||
return isr;
|
||||
|
||||
/* This code is used with the timebase frozen, we cannot rely
|
||||
* on udelay ! For now, just use a bogus loop
|
||||
*/
|
||||
for (j = 1; j < 10000; j++)
|
||||
mb();
|
||||
}
|
||||
return isr;
|
||||
}
|
||||
|
||||
static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int *rc, u8 **data, int *len, u8 isr)
|
||||
{
|
||||
u8 ack;
|
||||
|
||||
DBG("kw_handle_interrupt(%s, isr: %x)\n", __kw_state_names[state], isr);
|
||||
|
||||
if (isr == 0) {
|
||||
if (state != state_stop) {
|
||||
DBG("KW: Timeout !\n");
|
||||
*rc = -EIO;
|
||||
goto stop;
|
||||
}
|
||||
if (state == state_stop) {
|
||||
ack = kw_read_reg(reg_status);
|
||||
if (!(ack & KW_I2C_STAT_BUSY)) {
|
||||
state = state_idle;
|
||||
kw_write_reg(reg_ier, 0x00);
|
||||
}
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
if (isr & KW_I2C_IRQ_ADDR) {
|
||||
ack = kw_read_reg(reg_status);
|
||||
if (state != state_addr) {
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_ADDR);
|
||||
WRONG_STATE("KW_I2C_IRQ_ADDR");
|
||||
*rc = -EIO;
|
||||
goto stop;
|
||||
}
|
||||
if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
|
||||
*rc = -ENODEV;
|
||||
DBG("KW: NAK on address\n");
|
||||
return state_stop;
|
||||
} else {
|
||||
if (rw) {
|
||||
state = state_read;
|
||||
if (*len > 1)
|
||||
kw_write_reg(reg_control, KW_I2C_CTL_AAK);
|
||||
} else {
|
||||
state = state_write;
|
||||
kw_write_reg(reg_data, **data);
|
||||
(*data)++; (*len)--;
|
||||
}
|
||||
}
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_ADDR);
|
||||
}
|
||||
|
||||
if (isr & KW_I2C_IRQ_DATA) {
|
||||
if (state == state_read) {
|
||||
**data = kw_read_reg(reg_data);
|
||||
(*data)++; (*len)--;
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
|
||||
if ((*len) == 0)
|
||||
state = state_stop;
|
||||
else if ((*len) == 1)
|
||||
kw_write_reg(reg_control, 0);
|
||||
} else if (state == state_write) {
|
||||
ack = kw_read_reg(reg_status);
|
||||
if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
|
||||
DBG("KW: nack on data write\n");
|
||||
*rc = -EIO;
|
||||
goto stop;
|
||||
} else if (*len) {
|
||||
kw_write_reg(reg_data, **data);
|
||||
(*data)++; (*len)--;
|
||||
} else {
|
||||
kw_write_reg(reg_control, KW_I2C_CTL_STOP);
|
||||
state = state_stop;
|
||||
*rc = 0;
|
||||
}
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
|
||||
} else {
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
|
||||
WRONG_STATE("KW_I2C_IRQ_DATA");
|
||||
if (state != state_stop) {
|
||||
*rc = -EIO;
|
||||
goto stop;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (isr & KW_I2C_IRQ_STOP) {
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_STOP);
|
||||
if (state != state_stop) {
|
||||
WRONG_STATE("KW_I2C_IRQ_STOP");
|
||||
*rc = -EIO;
|
||||
}
|
||||
return state_idle;
|
||||
}
|
||||
|
||||
if (isr & KW_I2C_IRQ_START)
|
||||
kw_write_reg(reg_isr, KW_I2C_IRQ_START);
|
||||
|
||||
return state;
|
||||
|
||||
stop:
|
||||
kw_write_reg(reg_control, KW_I2C_CTL_STOP);
|
||||
return state_stop;
|
||||
}
|
||||
|
||||
static int keywest_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 subaddr, u8 *data, int len)
|
||||
{
|
||||
u8 mode_reg = host->speed;
|
||||
int state = state_addr;
|
||||
int rc = 0;
|
||||
|
||||
/* Setup mode & subaddress if any */
|
||||
switch(host->mode) {
|
||||
case pmac_low_i2c_mode_dumb:
|
||||
printk(KERN_ERR "low_i2c: Dumb mode not supported !\n");
|
||||
return -EINVAL;
|
||||
case pmac_low_i2c_mode_std:
|
||||
mode_reg |= KW_I2C_MODE_STANDARD;
|
||||
break;
|
||||
case pmac_low_i2c_mode_stdsub:
|
||||
mode_reg |= KW_I2C_MODE_STANDARDSUB;
|
||||
break;
|
||||
case pmac_low_i2c_mode_combined:
|
||||
mode_reg |= KW_I2C_MODE_COMBINED;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Setup channel & clear pending irqs */
|
||||
kw_write_reg(reg_isr, kw_read_reg(reg_isr));
|
||||
kw_write_reg(reg_mode, mode_reg | (host->channel << 4));
|
||||
kw_write_reg(reg_status, 0);
|
||||
|
||||
/* Set up address and r/w bit */
|
||||
kw_write_reg(reg_addr, addr);
|
||||
|
||||
/* Set up the sub address */
|
||||
if ((mode_reg & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_STANDARDSUB
|
||||
|| (mode_reg & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_COMBINED)
|
||||
kw_write_reg(reg_subaddr, subaddr);
|
||||
|
||||
/* Start sending address & disable interrupt*/
|
||||
kw_write_reg(reg_ier, 0 /*KW_I2C_IRQ_MASK*/);
|
||||
kw_write_reg(reg_control, KW_I2C_CTL_XADDR);
|
||||
|
||||
/* State machine, to turn into an interrupt handler */
|
||||
while(state != state_idle) {
|
||||
u8 isr = kw_wait_interrupt(host);
|
||||
state = kw_handle_interrupt(host, state, addr & 1, &rc, &data, &len, isr);
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
static void keywest_low_i2c_add(struct device_node *np)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(NULL);
|
||||
u32 *psteps, *prate, steps, aoffset = 0;
|
||||
struct device_node *parent;
|
||||
|
||||
if (host == NULL) {
|
||||
printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
|
||||
np->full_name);
|
||||
return;
|
||||
}
|
||||
memset(host, 0, sizeof(*host));
|
||||
|
||||
init_MUTEX(&host->mutex);
|
||||
host->np = of_node_get(np);
|
||||
psteps = (u32 *)get_property(np, "AAPL,address-step", NULL);
|
||||
steps = psteps ? (*psteps) : 0x10;
|
||||
for (host->bsteps = 0; (steps & 0x01) == 0; host->bsteps++)
|
||||
steps >>= 1;
|
||||
parent = of_get_parent(np);
|
||||
host->num_channels = 1;
|
||||
if (parent && parent->name[0] == 'u') {
|
||||
host->num_channels = 2;
|
||||
aoffset = 3;
|
||||
}
|
||||
/* Select interface rate */
|
||||
host->speed = KW_I2C_MODE_100KHZ;
|
||||
prate = (u32 *)get_property(np, "AAPL,i2c-rate", NULL);
|
||||
if (prate) switch(*prate) {
|
||||
case 100:
|
||||
host->speed = KW_I2C_MODE_100KHZ;
|
||||
break;
|
||||
case 50:
|
||||
host->speed = KW_I2C_MODE_50KHZ;
|
||||
break;
|
||||
case 25:
|
||||
host->speed = KW_I2C_MODE_25KHZ;
|
||||
break;
|
||||
}
|
||||
|
||||
host->mode = pmac_low_i2c_mode_std;
|
||||
host->base = ioremap(np->addrs[0].address + aoffset,
|
||||
np->addrs[0].size);
|
||||
host->func = keywest_low_i2c_func;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* PMU implementation
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
|
||||
static int pmu_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len)
|
||||
{
|
||||
// TODO
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static void pmu_low_i2c_add(struct device_node *np)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(NULL);
|
||||
|
||||
if (host == NULL) {
|
||||
printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
|
||||
np->full_name);
|
||||
return;
|
||||
}
|
||||
memset(host, 0, sizeof(*host));
|
||||
|
||||
init_MUTEX(&host->mutex);
|
||||
host->np = of_node_get(np);
|
||||
host->num_channels = 3;
|
||||
host->mode = pmac_low_i2c_mode_std;
|
||||
host->func = pmu_low_i2c_func;
|
||||
}
|
||||
|
||||
#endif /* CONFIG_ADB_PMU */
|
||||
|
||||
void __init pmac_init_low_i2c(void)
|
||||
{
|
||||
struct device_node *np;
|
||||
|
||||
/* Probe keywest-i2c busses */
|
||||
np = of_find_compatible_node(NULL, "i2c", "keywest-i2c");
|
||||
while(np) {
|
||||
keywest_low_i2c_add(np);
|
||||
np = of_find_compatible_node(np, "i2c", "keywest-i2c");
|
||||
}
|
||||
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
/* Probe PMU busses */
|
||||
np = of_find_node_by_name(NULL, "via-pmu");
|
||||
if (np)
|
||||
pmu_low_i2c_add(np);
|
||||
#endif /* CONFIG_ADB_PMU */
|
||||
|
||||
/* TODO: Add CUDA support as well */
|
||||
}
|
||||
|
||||
int pmac_low_i2c_lock(struct device_node *np)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(np);
|
||||
|
||||
if (!host)
|
||||
return -ENODEV;
|
||||
down(&host->mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_low_i2c_lock);
|
||||
|
||||
int pmac_low_i2c_unlock(struct device_node *np)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(np);
|
||||
|
||||
if (!host)
|
||||
return -ENODEV;
|
||||
up(&host->mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_low_i2c_unlock);
|
||||
|
||||
|
||||
int pmac_low_i2c_open(struct device_node *np, int channel)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(np);
|
||||
|
||||
if (!host)
|
||||
return -ENODEV;
|
||||
|
||||
if (channel >= host->num_channels)
|
||||
return -EINVAL;
|
||||
|
||||
down(&host->mutex);
|
||||
host->is_open = 1;
|
||||
host->channel = channel;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_low_i2c_open);
|
||||
|
||||
int pmac_low_i2c_close(struct device_node *np)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(np);
|
||||
|
||||
if (!host)
|
||||
return -ENODEV;
|
||||
|
||||
host->is_open = 0;
|
||||
up(&host->mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_low_i2c_close);
|
||||
|
||||
int pmac_low_i2c_setmode(struct device_node *np, int mode)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(np);
|
||||
|
||||
if (!host)
|
||||
return -ENODEV;
|
||||
WARN_ON(!host->is_open);
|
||||
host->mode = mode;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_low_i2c_setmode);
|
||||
|
||||
int pmac_low_i2c_xfer(struct device_node *np, u8 addrdir, u8 subaddr, u8 *data, int len)
|
||||
{
|
||||
struct low_i2c_host *host = find_low_i2c_host(np);
|
||||
|
||||
if (!host)
|
||||
return -ENODEV;
|
||||
WARN_ON(!host->is_open);
|
||||
|
||||
return host->func(host, addrdir, subaddr, data, len);
|
||||
}
|
||||
EXPORT_SYMBOL(pmac_low_i2c_xfer);
|
||||
|
|
@ -1,493 +0,0 @@
|
|||
/*
|
||||
* arch/ppc/platforms/pmac_nvram.c
|
||||
*
|
||||
* Copyright (C) 2002 Benjamin Herrenschmidt (benh@kernel.crashing.org)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* Todo: - add support for the OF persistent properties
|
||||
*/
|
||||
#include <linux/config.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/stddef.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/bootmem.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <asm/sections.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/nvram.h>
|
||||
|
||||
#define DEBUG
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DBG(x...) printk(x)
|
||||
#else
|
||||
#define DBG(x...)
|
||||
#endif
|
||||
|
||||
#define NVRAM_SIZE 0x2000 /* 8kB of non-volatile RAM */
|
||||
|
||||
#define CORE99_SIGNATURE 0x5a
|
||||
#define CORE99_ADLER_START 0x14
|
||||
|
||||
/* On Core99, nvram is either a sharp, a micron or an AMD flash */
|
||||
#define SM_FLASH_STATUS_DONE 0x80
|
||||
#define SM_FLASH_STATUS_ERR 0x38
|
||||
|
||||
#define SM_FLASH_CMD_ERASE_CONFIRM 0xd0
|
||||
#define SM_FLASH_CMD_ERASE_SETUP 0x20
|
||||
#define SM_FLASH_CMD_RESET 0xff
|
||||
#define SM_FLASH_CMD_WRITE_SETUP 0x40
|
||||
#define SM_FLASH_CMD_CLEAR_STATUS 0x50
|
||||
#define SM_FLASH_CMD_READ_STATUS 0x70
|
||||
|
||||
/* CHRP NVRAM header */
|
||||
struct chrp_header {
|
||||
u8 signature;
|
||||
u8 cksum;
|
||||
u16 len;
|
||||
char name[12];
|
||||
u8 data[0];
|
||||
};
|
||||
|
||||
struct core99_header {
|
||||
struct chrp_header hdr;
|
||||
u32 adler;
|
||||
u32 generation;
|
||||
u32 reserved[2];
|
||||
};
|
||||
|
||||
/*
|
||||
* Read and write the non-volatile RAM on PowerMacs and CHRP machines.
|
||||
*/
|
||||
static volatile unsigned char *nvram_data;
|
||||
static int core99_bank = 0;
|
||||
// XXX Turn that into a sem
|
||||
static DEFINE_SPINLOCK(nv_lock);
|
||||
|
||||
extern int system_running;
|
||||
|
||||
static int (*core99_write_bank)(int bank, u8* datas);
|
||||
static int (*core99_erase_bank)(int bank);
|
||||
|
||||
static char *nvram_image;
|
||||
|
||||
|
||||
static ssize_t core99_nvram_read(char *buf, size_t count, loff_t *index)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (nvram_image == NULL)
|
||||
return -ENODEV;
|
||||
if (*index > NVRAM_SIZE)
|
||||
return 0;
|
||||
|
||||
i = *index;
|
||||
if (i + count > NVRAM_SIZE)
|
||||
count = NVRAM_SIZE - i;
|
||||
|
||||
memcpy(buf, &nvram_image[i], count);
|
||||
*index = i + count;
|
||||
return count;
|
||||
}
|
||||
|
||||
static ssize_t core99_nvram_write(char *buf, size_t count, loff_t *index)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (nvram_image == NULL)
|
||||
return -ENODEV;
|
||||
if (*index > NVRAM_SIZE)
|
||||
return 0;
|
||||
|
||||
i = *index;
|
||||
if (i + count > NVRAM_SIZE)
|
||||
count = NVRAM_SIZE - i;
|
||||
|
||||
memcpy(&nvram_image[i], buf, count);
|
||||
*index = i + count;
|
||||
return count;
|
||||
}
|
||||
|
||||
static ssize_t core99_nvram_size(void)
|
||||
{
|
||||
if (nvram_image == NULL)
|
||||
return -ENODEV;
|
||||
return NVRAM_SIZE;
|
||||
}
|
||||
|
||||
static u8 chrp_checksum(struct chrp_header* hdr)
|
||||
{
|
||||
u8 *ptr;
|
||||
u16 sum = hdr->signature;
|
||||
for (ptr = (u8 *)&hdr->len; ptr < hdr->data; ptr++)
|
||||
sum += *ptr;
|
||||
while (sum > 0xFF)
|
||||
sum = (sum & 0xFF) + (sum>>8);
|
||||
return sum;
|
||||
}
|
||||
|
||||
static u32 core99_calc_adler(u8 *buffer)
|
||||
{
|
||||
int cnt;
|
||||
u32 low, high;
|
||||
|
||||
buffer += CORE99_ADLER_START;
|
||||
low = 1;
|
||||
high = 0;
|
||||
for (cnt=0; cnt<(NVRAM_SIZE-CORE99_ADLER_START); cnt++) {
|
||||
if ((cnt % 5000) == 0) {
|
||||
high %= 65521UL;
|
||||
high %= 65521UL;
|
||||
}
|
||||
low += buffer[cnt];
|
||||
high += low;
|
||||
}
|
||||
low %= 65521UL;
|
||||
high %= 65521UL;
|
||||
|
||||
return (high << 16) | low;
|
||||
}
|
||||
|
||||
static u32 core99_check(u8* datas)
|
||||
{
|
||||
struct core99_header* hdr99 = (struct core99_header*)datas;
|
||||
|
||||
if (hdr99->hdr.signature != CORE99_SIGNATURE) {
|
||||
DBG("Invalid signature\n");
|
||||
return 0;
|
||||
}
|
||||
if (hdr99->hdr.cksum != chrp_checksum(&hdr99->hdr)) {
|
||||
DBG("Invalid checksum\n");
|
||||
return 0;
|
||||
}
|
||||
if (hdr99->adler != core99_calc_adler(datas)) {
|
||||
DBG("Invalid adler\n");
|
||||
return 0;
|
||||
}
|
||||
return hdr99->generation;
|
||||
}
|
||||
|
||||
static int sm_erase_bank(int bank)
|
||||
{
|
||||
int stat, i;
|
||||
unsigned long timeout;
|
||||
|
||||
u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
|
||||
|
||||
DBG("nvram: Sharp/Micron Erasing bank %d...\n", bank);
|
||||
|
||||
out_8(base, SM_FLASH_CMD_ERASE_SETUP);
|
||||
out_8(base, SM_FLASH_CMD_ERASE_CONFIRM);
|
||||
timeout = 0;
|
||||
do {
|
||||
if (++timeout > 1000000) {
|
||||
printk(KERN_ERR "nvram: Sharp/Miron flash erase timeout !\n");
|
||||
break;
|
||||
}
|
||||
out_8(base, SM_FLASH_CMD_READ_STATUS);
|
||||
stat = in_8(base);
|
||||
} while (!(stat & SM_FLASH_STATUS_DONE));
|
||||
|
||||
out_8(base, SM_FLASH_CMD_CLEAR_STATUS);
|
||||
out_8(base, SM_FLASH_CMD_RESET);
|
||||
|
||||
for (i=0; i<NVRAM_SIZE; i++)
|
||||
if (base[i] != 0xff) {
|
||||
printk(KERN_ERR "nvram: Sharp/Micron flash erase failed !\n");
|
||||
return -ENXIO;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sm_write_bank(int bank, u8* datas)
|
||||
{
|
||||
int i, stat = 0;
|
||||
unsigned long timeout;
|
||||
|
||||
u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
|
||||
|
||||
DBG("nvram: Sharp/Micron Writing bank %d...\n", bank);
|
||||
|
||||
for (i=0; i<NVRAM_SIZE; i++) {
|
||||
out_8(base+i, SM_FLASH_CMD_WRITE_SETUP);
|
||||
udelay(1);
|
||||
out_8(base+i, datas[i]);
|
||||
timeout = 0;
|
||||
do {
|
||||
if (++timeout > 1000000) {
|
||||
printk(KERN_ERR "nvram: Sharp/Micron flash write timeout !\n");
|
||||
break;
|
||||
}
|
||||
out_8(base, SM_FLASH_CMD_READ_STATUS);
|
||||
stat = in_8(base);
|
||||
} while (!(stat & SM_FLASH_STATUS_DONE));
|
||||
if (!(stat & SM_FLASH_STATUS_DONE))
|
||||
break;
|
||||
}
|
||||
out_8(base, SM_FLASH_CMD_CLEAR_STATUS);
|
||||
out_8(base, SM_FLASH_CMD_RESET);
|
||||
for (i=0; i<NVRAM_SIZE; i++)
|
||||
if (base[i] != datas[i]) {
|
||||
printk(KERN_ERR "nvram: Sharp/Micron flash write failed !\n");
|
||||
return -ENXIO;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int amd_erase_bank(int bank)
|
||||
{
|
||||
int i, stat = 0;
|
||||
unsigned long timeout;
|
||||
|
||||
u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
|
||||
|
||||
DBG("nvram: AMD Erasing bank %d...\n", bank);
|
||||
|
||||
/* Unlock 1 */
|
||||
out_8(base+0x555, 0xaa);
|
||||
udelay(1);
|
||||
/* Unlock 2 */
|
||||
out_8(base+0x2aa, 0x55);
|
||||
udelay(1);
|
||||
|
||||
/* Sector-Erase */
|
||||
out_8(base+0x555, 0x80);
|
||||
udelay(1);
|
||||
out_8(base+0x555, 0xaa);
|
||||
udelay(1);
|
||||
out_8(base+0x2aa, 0x55);
|
||||
udelay(1);
|
||||
out_8(base, 0x30);
|
||||
udelay(1);
|
||||
|
||||
timeout = 0;
|
||||
do {
|
||||
if (++timeout > 1000000) {
|
||||
printk(KERN_ERR "nvram: AMD flash erase timeout !\n");
|
||||
break;
|
||||
}
|
||||
stat = in_8(base) ^ in_8(base);
|
||||
} while (stat != 0);
|
||||
|
||||
/* Reset */
|
||||
out_8(base, 0xf0);
|
||||
udelay(1);
|
||||
|
||||
for (i=0; i<NVRAM_SIZE; i++)
|
||||
if (base[i] != 0xff) {
|
||||
printk(KERN_ERR "nvram: AMD flash erase failed !\n");
|
||||
return -ENXIO;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int amd_write_bank(int bank, u8* datas)
|
||||
{
|
||||
int i, stat = 0;
|
||||
unsigned long timeout;
|
||||
|
||||
u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
|
||||
|
||||
DBG("nvram: AMD Writing bank %d...\n", bank);
|
||||
|
||||
for (i=0; i<NVRAM_SIZE; i++) {
|
||||
/* Unlock 1 */
|
||||
out_8(base+0x555, 0xaa);
|
||||
udelay(1);
|
||||
/* Unlock 2 */
|
||||
out_8(base+0x2aa, 0x55);
|
||||
udelay(1);
|
||||
|
||||
/* Write single word */
|
||||
out_8(base+0x555, 0xa0);
|
||||
udelay(1);
|
||||
out_8(base+i, datas[i]);
|
||||
|
||||
timeout = 0;
|
||||
do {
|
||||
if (++timeout > 1000000) {
|
||||
printk(KERN_ERR "nvram: AMD flash write timeout !\n");
|
||||
break;
|
||||
}
|
||||
stat = in_8(base) ^ in_8(base);
|
||||
} while (stat != 0);
|
||||
if (stat != 0)
|
||||
break;
|
||||
}
|
||||
|
||||
/* Reset */
|
||||
out_8(base, 0xf0);
|
||||
udelay(1);
|
||||
|
||||
for (i=0; i<NVRAM_SIZE; i++)
|
||||
if (base[i] != datas[i]) {
|
||||
printk(KERN_ERR "nvram: AMD flash write failed !\n");
|
||||
return -ENXIO;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static void core99_nvram_sync(void)
|
||||
{
|
||||
struct core99_header* hdr99;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&nv_lock, flags);
|
||||
if (!memcmp(nvram_image, (u8*)nvram_data + core99_bank*NVRAM_SIZE,
|
||||
NVRAM_SIZE))
|
||||
goto bail;
|
||||
|
||||
DBG("Updating nvram...\n");
|
||||
|
||||
hdr99 = (struct core99_header*)nvram_image;
|
||||
hdr99->generation++;
|
||||
hdr99->hdr.signature = CORE99_SIGNATURE;
|
||||
hdr99->hdr.cksum = chrp_checksum(&hdr99->hdr);
|
||||
hdr99->adler = core99_calc_adler(nvram_image);
|
||||
core99_bank = core99_bank ? 0 : 1;
|
||||
if (core99_erase_bank)
|
||||
if (core99_erase_bank(core99_bank)) {
|
||||
printk("nvram: Error erasing bank %d\n", core99_bank);
|
||||
goto bail;
|
||||
}
|
||||
if (core99_write_bank)
|
||||
if (core99_write_bank(core99_bank, nvram_image))
|
||||
printk("nvram: Error writing bank %d\n", core99_bank);
|
||||
bail:
|
||||
spin_unlock_irqrestore(&nv_lock, flags);
|
||||
}
|
||||
|
||||
int __init pmac_nvram_init(void)
|
||||
{
|
||||
struct device_node *dp;
|
||||
u32 gen_bank0, gen_bank1;
|
||||
int i;
|
||||
|
||||
dp = find_devices("nvram");
|
||||
if (dp == NULL) {
|
||||
printk(KERN_ERR "Can't find NVRAM device\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
if (!device_is_compatible(dp, "nvram,flash")) {
|
||||
printk(KERN_ERR "Incompatible type of NVRAM\n");
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
nvram_image = alloc_bootmem(NVRAM_SIZE);
|
||||
if (nvram_image == NULL) {
|
||||
printk(KERN_ERR "nvram: can't allocate ram image\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
nvram_data = ioremap(dp->addrs[0].address, NVRAM_SIZE*2);
|
||||
|
||||
DBG("nvram: Checking bank 0...\n");
|
||||
|
||||
gen_bank0 = core99_check((u8 *)nvram_data);
|
||||
gen_bank1 = core99_check((u8 *)nvram_data + NVRAM_SIZE);
|
||||
core99_bank = (gen_bank0 < gen_bank1) ? 1 : 0;
|
||||
|
||||
DBG("nvram: gen0=%d, gen1=%d\n", gen_bank0, gen_bank1);
|
||||
DBG("nvram: Active bank is: %d\n", core99_bank);
|
||||
|
||||
for (i=0; i<NVRAM_SIZE; i++)
|
||||
nvram_image[i] = nvram_data[i + core99_bank*NVRAM_SIZE];
|
||||
|
||||
ppc_md.nvram_read = core99_nvram_read;
|
||||
ppc_md.nvram_write = core99_nvram_write;
|
||||
ppc_md.nvram_size = core99_nvram_size;
|
||||
ppc_md.nvram_sync = core99_nvram_sync;
|
||||
|
||||
/*
|
||||
* Maybe we could be smarter here though making an exclusive list
|
||||
* of known flash chips is a bit nasty as older OF didn't provide us
|
||||
* with a useful "compatible" entry. A solution would be to really
|
||||
* identify the chip using flash id commands and base ourselves on
|
||||
* a list of known chips IDs
|
||||
*/
|
||||
if (device_is_compatible(dp, "amd-0137")) {
|
||||
core99_erase_bank = amd_erase_bank;
|
||||
core99_write_bank = amd_write_bank;
|
||||
} else {
|
||||
core99_erase_bank = sm_erase_bank;
|
||||
core99_write_bank = sm_write_bank;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int pmac_get_partition(int partition)
|
||||
{
|
||||
struct nvram_partition *part;
|
||||
const char *name;
|
||||
int sig;
|
||||
|
||||
switch(partition) {
|
||||
case pmac_nvram_OF:
|
||||
name = "common";
|
||||
sig = NVRAM_SIG_SYS;
|
||||
break;
|
||||
case pmac_nvram_XPRAM:
|
||||
name = "APL,MacOS75";
|
||||
sig = NVRAM_SIG_OS;
|
||||
break;
|
||||
case pmac_nvram_NR:
|
||||
default:
|
||||
/* Oldworld stuff */
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
part = nvram_find_partition(sig, name);
|
||||
if (part == NULL)
|
||||
return 0;
|
||||
|
||||
return part->index;
|
||||
}
|
||||
|
||||
u8 pmac_xpram_read(int xpaddr)
|
||||
{
|
||||
int offset = pmac_get_partition(pmac_nvram_XPRAM);
|
||||
loff_t index;
|
||||
u8 buf;
|
||||
ssize_t count;
|
||||
|
||||
if (offset < 0 || xpaddr < 0 || xpaddr > 0x100)
|
||||
return 0xff;
|
||||
index = offset + xpaddr;
|
||||
|
||||
count = ppc_md.nvram_read(&buf, 1, &index);
|
||||
if (count != 1)
|
||||
return 0xff;
|
||||
return buf;
|
||||
}
|
||||
|
||||
void pmac_xpram_write(int xpaddr, u8 data)
|
||||
{
|
||||
int offset = pmac_get_partition(pmac_nvram_XPRAM);
|
||||
loff_t index;
|
||||
u8 buf;
|
||||
|
||||
if (offset < 0 || xpaddr < 0 || xpaddr > 0x100)
|
||||
return;
|
||||
index = offset + xpaddr;
|
||||
buf = data;
|
||||
|
||||
ppc_md.nvram_write(&buf, 1, &index);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(pmac_get_partition);
|
||||
EXPORT_SYMBOL(pmac_xpram_read);
|
||||
EXPORT_SYMBOL(pmac_xpram_write);
|
|
@ -1,793 +0,0 @@
|
|||
/*
|
||||
* Support for PCI bridges found on Power Macintoshes.
|
||||
* At present the "bandit" and "chaos" bridges are supported.
|
||||
* Fortunately you access configuration space in the same
|
||||
* way with either bridge.
|
||||
*
|
||||
* Copyright (C) 2003 Benjamin Herrenschmuidt (benh@kernel.crashing.org)
|
||||
* Copyright (C) 1997 Paul Mackerras (paulus@samba.org)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the License, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/bootmem.h>
|
||||
|
||||
#include <asm/sections.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/pci-bridge.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/pmac_feature.h>
|
||||
#include <asm/iommu.h>
|
||||
#include <asm/ppc-pci.h>
|
||||
|
||||
#include "pmac.h"
|
||||
|
||||
#define DEBUG
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DBG(x...) printk(x)
|
||||
#else
|
||||
#define DBG(x...)
|
||||
#endif
|
||||
|
||||
/* XXX Could be per-controller, but I don't think we risk anything by
|
||||
* assuming we won't have both UniNorth and Bandit */
|
||||
static int has_uninorth;
|
||||
static struct pci_controller *u3_agp;
|
||||
struct device_node *k2_skiplist[2];
|
||||
|
||||
static int __init fixup_one_level_bus_range(struct device_node *node, int higher)
|
||||
{
|
||||
for (; node != 0;node = node->sibling) {
|
||||
int * bus_range;
|
||||
unsigned int *class_code;
|
||||
int len;
|
||||
|
||||
/* For PCI<->PCI bridges or CardBus bridges, we go down */
|
||||
class_code = (unsigned int *) get_property(node, "class-code", NULL);
|
||||
if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
|
||||
(*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
|
||||
continue;
|
||||
bus_range = (int *) get_property(node, "bus-range", &len);
|
||||
if (bus_range != NULL && len > 2 * sizeof(int)) {
|
||||
if (bus_range[1] > higher)
|
||||
higher = bus_range[1];
|
||||
}
|
||||
higher = fixup_one_level_bus_range(node->child, higher);
|
||||
}
|
||||
return higher;
|
||||
}
|
||||
|
||||
/* This routine fixes the "bus-range" property of all bridges in the
|
||||
* system since they tend to have their "last" member wrong on macs
|
||||
*
|
||||
* Note that the bus numbers manipulated here are OF bus numbers, they
|
||||
* are not Linux bus numbers.
|
||||
*/
|
||||
static void __init fixup_bus_range(struct device_node *bridge)
|
||||
{
|
||||
int * bus_range;
|
||||
int len;
|
||||
|
||||
/* Lookup the "bus-range" property for the hose */
|
||||
bus_range = (int *) get_property(bridge, "bus-range", &len);
|
||||
if (bus_range == NULL || len < 2 * sizeof(int)) {
|
||||
printk(KERN_WARNING "Can't get bus-range for %s\n",
|
||||
bridge->full_name);
|
||||
return;
|
||||
}
|
||||
bus_range[1] = fixup_one_level_bus_range(bridge->child, bus_range[1]);
|
||||
}
|
||||
|
||||
/*
|
||||
* Apple MacRISC (U3, UniNorth, Bandit, Chaos) PCI controllers.
|
||||
*
|
||||
* The "Bandit" version is present in all early PCI PowerMacs,
|
||||
* and up to the first ones using Grackle. Some machines may
|
||||
* have 2 bandit controllers (2 PCI busses).
|
||||
*
|
||||
* "Chaos" is used in some "Bandit"-type machines as a bridge
|
||||
* for the separate display bus. It is accessed the same
|
||||
* way as bandit, but cannot be probed for devices. It therefore
|
||||
* has its own config access functions.
|
||||
*
|
||||
* The "UniNorth" version is present in all Core99 machines
|
||||
* (iBook, G4, new IMacs, and all the recent Apple machines).
|
||||
* It contains 3 controllers in one ASIC.
|
||||
*
|
||||
* The U3 is the bridge used on G5 machines. It contains on
|
||||
* AGP bus which is dealt with the old UniNorth access routines
|
||||
* and an HyperTransport bus which uses its own set of access
|
||||
* functions.
|
||||
*/
|
||||
|
||||
#define MACRISC_CFA0(devfn, off) \
|
||||
((1 << (unsigned long)PCI_SLOT(dev_fn)) \
|
||||
| (((unsigned long)PCI_FUNC(dev_fn)) << 8) \
|
||||
| (((unsigned long)(off)) & 0xFCUL))
|
||||
|
||||
#define MACRISC_CFA1(bus, devfn, off) \
|
||||
((((unsigned long)(bus)) << 16) \
|
||||
|(((unsigned long)(devfn)) << 8) \
|
||||
|(((unsigned long)(off)) & 0xFCUL) \
|
||||
|1UL)
|
||||
|
||||
static unsigned long macrisc_cfg_access(struct pci_controller* hose,
|
||||
u8 bus, u8 dev_fn, u8 offset)
|
||||
{
|
||||
unsigned int caddr;
|
||||
|
||||
if (bus == hose->first_busno) {
|
||||
if (dev_fn < (11 << 3))
|
||||
return 0;
|
||||
caddr = MACRISC_CFA0(dev_fn, offset);
|
||||
} else
|
||||
caddr = MACRISC_CFA1(bus, dev_fn, offset);
|
||||
|
||||
/* Uninorth will return garbage if we don't read back the value ! */
|
||||
do {
|
||||
out_le32(hose->cfg_addr, caddr);
|
||||
} while (in_le32(hose->cfg_addr) != caddr);
|
||||
|
||||
offset &= has_uninorth ? 0x07 : 0x03;
|
||||
return ((unsigned long)hose->cfg_data) + offset;
|
||||
}
|
||||
|
||||
static int macrisc_read_config(struct pci_bus *bus, unsigned int devfn,
|
||||
int offset, int len, u32 *val)
|
||||
{
|
||||
struct pci_controller *hose;
|
||||
unsigned long addr;
|
||||
|
||||
hose = pci_bus_to_host(bus);
|
||||
if (hose == NULL)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
addr = macrisc_cfg_access(hose, bus->number, devfn, offset);
|
||||
if (!addr)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
/*
|
||||
* Note: the caller has already checked that offset is
|
||||
* suitably aligned and that len is 1, 2 or 4.
|
||||
*/
|
||||
switch (len) {
|
||||
case 1:
|
||||
*val = in_8((u8 *)addr);
|
||||
break;
|
||||
case 2:
|
||||
*val = in_le16((u16 *)addr);
|
||||
break;
|
||||
default:
|
||||
*val = in_le32((u32 *)addr);
|
||||
break;
|
||||
}
|
||||
return PCIBIOS_SUCCESSFUL;
|
||||
}
|
||||
|
||||
static int macrisc_write_config(struct pci_bus *bus, unsigned int devfn,
|
||||
int offset, int len, u32 val)
|
||||
{
|
||||
struct pci_controller *hose;
|
||||
unsigned long addr;
|
||||
|
||||
hose = pci_bus_to_host(bus);
|
||||
if (hose == NULL)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
addr = macrisc_cfg_access(hose, bus->number, devfn, offset);
|
||||
if (!addr)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
/*
|
||||
* Note: the caller has already checked that offset is
|
||||
* suitably aligned and that len is 1, 2 or 4.
|
||||
*/
|
||||
switch (len) {
|
||||
case 1:
|
||||
out_8((u8 *)addr, val);
|
||||
(void) in_8((u8 *)addr);
|
||||
break;
|
||||
case 2:
|
||||
out_le16((u16 *)addr, val);
|
||||
(void) in_le16((u16 *)addr);
|
||||
break;
|
||||
default:
|
||||
out_le32((u32 *)addr, val);
|
||||
(void) in_le32((u32 *)addr);
|
||||
break;
|
||||
}
|
||||
return PCIBIOS_SUCCESSFUL;
|
||||
}
|
||||
|
||||
static struct pci_ops macrisc_pci_ops =
|
||||
{
|
||||
macrisc_read_config,
|
||||
macrisc_write_config
|
||||
};
|
||||
|
||||
/*
|
||||
* These versions of U3 HyperTransport config space access ops do not
|
||||
* implement self-view of the HT host yet
|
||||
*/
|
||||
|
||||
/*
|
||||
* This function deals with some "special cases" devices.
|
||||
*
|
||||
* 0 -> No special case
|
||||
* 1 -> Skip the device but act as if the access was successfull
|
||||
* (return 0xff's on reads, eventually, cache config space
|
||||
* accesses in a later version)
|
||||
* -1 -> Hide the device (unsuccessful acess)
|
||||
*/
|
||||
static int u3_ht_skip_device(struct pci_controller *hose,
|
||||
struct pci_bus *bus, unsigned int devfn)
|
||||
{
|
||||
struct device_node *busdn, *dn;
|
||||
int i;
|
||||
|
||||
/* We only allow config cycles to devices that are in OF device-tree
|
||||
* as we are apparently having some weird things going on with some
|
||||
* revs of K2 on recent G5s
|
||||
*/
|
||||
if (bus->self)
|
||||
busdn = pci_device_to_OF_node(bus->self);
|
||||
else
|
||||
busdn = hose->arch_data;
|
||||
for (dn = busdn->child; dn; dn = dn->sibling)
|
||||
if (dn->data && PCI_DN(dn)->devfn == devfn)
|
||||
break;
|
||||
if (dn == NULL)
|
||||
return -1;
|
||||
|
||||
/*
|
||||
* When a device in K2 is powered down, we die on config
|
||||
* cycle accesses. Fix that here.
|
||||
*/
|
||||
for (i=0; i<2; i++)
|
||||
if (k2_skiplist[i] == dn)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define U3_HT_CFA0(devfn, off) \
|
||||
((((unsigned long)devfn) << 8) | offset)
|
||||
#define U3_HT_CFA1(bus, devfn, off) \
|
||||
(U3_HT_CFA0(devfn, off) \
|
||||
+ (((unsigned long)bus) << 16) \
|
||||
+ 0x01000000UL)
|
||||
|
||||
static unsigned long u3_ht_cfg_access(struct pci_controller* hose,
|
||||
u8 bus, u8 devfn, u8 offset)
|
||||
{
|
||||
if (bus == hose->first_busno) {
|
||||
/* For now, we don't self probe U3 HT bridge */
|
||||
if (PCI_SLOT(devfn) == 0)
|
||||
return 0;
|
||||
return ((unsigned long)hose->cfg_data) + U3_HT_CFA0(devfn, offset);
|
||||
} else
|
||||
return ((unsigned long)hose->cfg_data) + U3_HT_CFA1(bus, devfn, offset);
|
||||
}
|
||||
|
||||
static int u3_ht_read_config(struct pci_bus *bus, unsigned int devfn,
|
||||
int offset, int len, u32 *val)
|
||||
{
|
||||
struct pci_controller *hose;
|
||||
unsigned long addr;
|
||||
|
||||
|
||||
hose = pci_bus_to_host(bus);
|
||||
if (hose == NULL)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
|
||||
if (!addr)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
switch (u3_ht_skip_device(hose, bus, devfn)) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
switch (len) {
|
||||
case 1:
|
||||
*val = 0xff; break;
|
||||
case 2:
|
||||
*val = 0xffff; break;
|
||||
default:
|
||||
*val = 0xfffffffful; break;
|
||||
}
|
||||
return PCIBIOS_SUCCESSFUL;
|
||||
default:
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
}
|
||||
|
||||
/*
|
||||
* Note: the caller has already checked that offset is
|
||||
* suitably aligned and that len is 1, 2 or 4.
|
||||
*/
|
||||
switch (len) {
|
||||
case 1:
|
||||
*val = in_8((u8 *)addr);
|
||||
break;
|
||||
case 2:
|
||||
*val = in_le16((u16 *)addr);
|
||||
break;
|
||||
default:
|
||||
*val = in_le32((u32 *)addr);
|
||||
break;
|
||||
}
|
||||
return PCIBIOS_SUCCESSFUL;
|
||||
}
|
||||
|
||||
static int u3_ht_write_config(struct pci_bus *bus, unsigned int devfn,
|
||||
int offset, int len, u32 val)
|
||||
{
|
||||
struct pci_controller *hose;
|
||||
unsigned long addr;
|
||||
|
||||
hose = pci_bus_to_host(bus);
|
||||
if (hose == NULL)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
|
||||
if (!addr)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
switch (u3_ht_skip_device(hose, bus, devfn)) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
return PCIBIOS_SUCCESSFUL;
|
||||
default:
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
}
|
||||
|
||||
/*
|
||||
* Note: the caller has already checked that offset is
|
||||
* suitably aligned and that len is 1, 2 or 4.
|
||||
*/
|
||||
switch (len) {
|
||||
case 1:
|
||||
out_8((u8 *)addr, val);
|
||||
(void) in_8((u8 *)addr);
|
||||
break;
|
||||
case 2:
|
||||
out_le16((u16 *)addr, val);
|
||||
(void) in_le16((u16 *)addr);
|
||||
break;
|
||||
default:
|
||||
out_le32((u32 *)addr, val);
|
||||
(void) in_le32((u32 *)addr);
|
||||
break;
|
||||
}
|
||||
return PCIBIOS_SUCCESSFUL;
|
||||
}
|
||||
|
||||
static struct pci_ops u3_ht_pci_ops =
|
||||
{
|
||||
u3_ht_read_config,
|
||||
u3_ht_write_config
|
||||
};
|
||||
|
||||
static void __init setup_u3_agp(struct pci_controller* hose)
|
||||
{
|
||||
/* On G5, we move AGP up to high bus number so we don't need
|
||||
* to reassign bus numbers for HT. If we ever have P2P bridges
|
||||
* on AGP, we'll have to move pci_assign_all_buses to the
|
||||
* pci_controller structure so we enable it for AGP and not for
|
||||
* HT childs.
|
||||
* We hard code the address because of the different size of
|
||||
* the reg address cell, we shall fix that by killing struct
|
||||
* reg_property and using some accessor functions instead
|
||||
*/
|
||||
hose->first_busno = 0xf0;
|
||||
hose->last_busno = 0xff;
|
||||
has_uninorth = 1;
|
||||
hose->ops = ¯isc_pci_ops;
|
||||
hose->cfg_addr = ioremap(0xf0000000 + 0x800000, 0x1000);
|
||||
hose->cfg_data = ioremap(0xf0000000 + 0xc00000, 0x1000);
|
||||
|
||||
u3_agp = hose;
|
||||
}
|
||||
|
||||
static void __init setup_u3_ht(struct pci_controller* hose)
|
||||
{
|
||||
struct device_node *np = (struct device_node *)hose->arch_data;
|
||||
int i, cur;
|
||||
|
||||
hose->ops = &u3_ht_pci_ops;
|
||||
|
||||
/* We hard code the address because of the different size of
|
||||
* the reg address cell, we shall fix that by killing struct
|
||||
* reg_property and using some accessor functions instead
|
||||
*/
|
||||
hose->cfg_data = (volatile unsigned char *)ioremap(0xf2000000, 0x02000000);
|
||||
|
||||
/*
|
||||
* /ht node doesn't expose a "ranges" property, so we "remove" regions that
|
||||
* have been allocated to AGP. So far, this version of the code doesn't assign
|
||||
* any of the 0xfxxxxxxx "fine" memory regions to /ht.
|
||||
* We need to fix that sooner or later by either parsing all child "ranges"
|
||||
* properties or figuring out the U3 address space decoding logic and
|
||||
* then read it's configuration register (if any).
|
||||
*/
|
||||
hose->io_base_phys = 0xf4000000;
|
||||
hose->io_base_virt = ioremap(hose->io_base_phys, 0x00400000);
|
||||
isa_io_base = pci_io_base = (unsigned long) hose->io_base_virt;
|
||||
hose->io_resource.name = np->full_name;
|
||||
hose->io_resource.start = 0;
|
||||
hose->io_resource.end = 0x003fffff;
|
||||
hose->io_resource.flags = IORESOURCE_IO;
|
||||
hose->pci_mem_offset = 0;
|
||||
hose->first_busno = 0;
|
||||
hose->last_busno = 0xef;
|
||||
hose->mem_resources[0].name = np->full_name;
|
||||
hose->mem_resources[0].start = 0x80000000;
|
||||
hose->mem_resources[0].end = 0xefffffff;
|
||||
hose->mem_resources[0].flags = IORESOURCE_MEM;
|
||||
|
||||
if (u3_agp == NULL) {
|
||||
DBG("U3 has no AGP, using full resource range\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* We "remove" the AGP resources from the resources allocated to HT, that
|
||||
* is we create "holes". However, that code does assumptions that so far
|
||||
* happen to be true (cross fingers...), typically that resources in the
|
||||
* AGP node are properly ordered
|
||||
*/
|
||||
cur = 0;
|
||||
for (i=0; i<3; i++) {
|
||||
struct resource *res = &u3_agp->mem_resources[i];
|
||||
if (res->flags != IORESOURCE_MEM)
|
||||
continue;
|
||||
/* We don't care about "fine" resources */
|
||||
if (res->start >= 0xf0000000)
|
||||
continue;
|
||||
/* Check if it's just a matter of "shrinking" us in one direction */
|
||||
if (hose->mem_resources[cur].start == res->start) {
|
||||
DBG("U3/HT: shrink start of %d, %08lx -> %08lx\n",
|
||||
cur, hose->mem_resources[cur].start, res->end + 1);
|
||||
hose->mem_resources[cur].start = res->end + 1;
|
||||
continue;
|
||||
}
|
||||
if (hose->mem_resources[cur].end == res->end) {
|
||||
DBG("U3/HT: shrink end of %d, %08lx -> %08lx\n",
|
||||
cur, hose->mem_resources[cur].end, res->start - 1);
|
||||
hose->mem_resources[cur].end = res->start - 1;
|
||||
continue;
|
||||
}
|
||||
/* No, it's not the case, we need a hole */
|
||||
if (cur == 2) {
|
||||
/* not enough resources for a hole, we drop part of the range */
|
||||
printk(KERN_WARNING "Running out of resources for /ht host !\n");
|
||||
hose->mem_resources[cur].end = res->start - 1;
|
||||
continue;
|
||||
}
|
||||
cur++;
|
||||
DBG("U3/HT: hole, %d end at %08lx, %d start at %08lx\n",
|
||||
cur-1, res->start - 1, cur, res->end + 1);
|
||||
hose->mem_resources[cur].name = np->full_name;
|
||||
hose->mem_resources[cur].flags = IORESOURCE_MEM;
|
||||
hose->mem_resources[cur].start = res->end + 1;
|
||||
hose->mem_resources[cur].end = hose->mem_resources[cur-1].end;
|
||||
hose->mem_resources[cur-1].end = res->start - 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void __init pmac_process_bridge_OF_ranges(struct pci_controller *hose,
|
||||
struct device_node *dev, int primary)
|
||||
{
|
||||
static unsigned int static_lc_ranges[2024];
|
||||
unsigned int *dt_ranges, *lc_ranges, *ranges, *prev;
|
||||
unsigned int size;
|
||||
int rlen = 0, orig_rlen;
|
||||
int memno = 0;
|
||||
struct resource *res;
|
||||
int np, na = prom_n_addr_cells(dev);
|
||||
|
||||
np = na + 5;
|
||||
|
||||
/* First we try to merge ranges to fix a problem with some pmacs
|
||||
* that can have more than 3 ranges, fortunately using contiguous
|
||||
* addresses -- BenH
|
||||
*/
|
||||
dt_ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
|
||||
if (!dt_ranges)
|
||||
return;
|
||||
/* lc_ranges = alloc_bootmem(rlen);*/
|
||||
lc_ranges = static_lc_ranges;
|
||||
if (!lc_ranges)
|
||||
return; /* what can we do here ? */
|
||||
memcpy(lc_ranges, dt_ranges, rlen);
|
||||
orig_rlen = rlen;
|
||||
|
||||
/* Let's work on a copy of the "ranges" property instead of damaging
|
||||
* the device-tree image in memory
|
||||
*/
|
||||
ranges = lc_ranges;
|
||||
prev = NULL;
|
||||
while ((rlen -= np * sizeof(unsigned int)) >= 0) {
|
||||
if (prev) {
|
||||
if (prev[0] == ranges[0] && prev[1] == ranges[1] &&
|
||||
(prev[2] + prev[na+4]) == ranges[2] &&
|
||||
(prev[na+2] + prev[na+4]) == ranges[na+2]) {
|
||||
prev[na+4] += ranges[na+4];
|
||||
ranges[0] = 0;
|
||||
ranges += np;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
prev = ranges;
|
||||
ranges += np;
|
||||
}
|
||||
|
||||
/*
|
||||
* The ranges property is laid out as an array of elements,
|
||||
* each of which comprises:
|
||||
* cells 0 - 2: a PCI address
|
||||
* cells 3 or 3+4: a CPU physical address
|
||||
* (size depending on dev->n_addr_cells)
|
||||
* cells 4+5 or 5+6: the size of the range
|
||||
*/
|
||||
ranges = lc_ranges;
|
||||
rlen = orig_rlen;
|
||||
while (ranges && (rlen -= np * sizeof(unsigned int)) >= 0) {
|
||||
res = NULL;
|
||||
size = ranges[na+4];
|
||||
switch (ranges[0] >> 24) {
|
||||
case 1: /* I/O space */
|
||||
if (ranges[2] != 0)
|
||||
break;
|
||||
hose->io_base_phys = ranges[na+2];
|
||||
/* limit I/O space to 16MB */
|
||||
if (size > 0x01000000)
|
||||
size = 0x01000000;
|
||||
hose->io_base_virt = ioremap(ranges[na+2], size);
|
||||
if (primary)
|
||||
isa_io_base = (unsigned long) hose->io_base_virt;
|
||||
res = &hose->io_resource;
|
||||
res->flags = IORESOURCE_IO;
|
||||
res->start = ranges[2];
|
||||
break;
|
||||
case 2: /* memory space */
|
||||
memno = 0;
|
||||
if (ranges[1] == 0 && ranges[2] == 0
|
||||
&& ranges[na+4] <= (16 << 20)) {
|
||||
/* 1st 16MB, i.e. ISA memory area */
|
||||
#if 0
|
||||
if (primary)
|
||||
isa_mem_base = ranges[na+2];
|
||||
#endif
|
||||
memno = 1;
|
||||
}
|
||||
while (memno < 3 && hose->mem_resources[memno].flags)
|
||||
++memno;
|
||||
if (memno == 0)
|
||||
hose->pci_mem_offset = ranges[na+2] - ranges[2];
|
||||
if (memno < 3) {
|
||||
res = &hose->mem_resources[memno];
|
||||
res->flags = IORESOURCE_MEM;
|
||||
res->start = ranges[na+2];
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (res != NULL) {
|
||||
res->name = dev->full_name;
|
||||
res->end = res->start + size - 1;
|
||||
res->parent = NULL;
|
||||
res->sibling = NULL;
|
||||
res->child = NULL;
|
||||
}
|
||||
ranges += np;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* We assume that if we have a G3 powermac, we have one bridge called
|
||||
* "pci" (a MPC106) and no bandit or chaos bridges, and contrariwise,
|
||||
* if we have one or more bandit or chaos bridges, we don't have a MPC106.
|
||||
*/
|
||||
static int __init add_bridge(struct device_node *dev)
|
||||
{
|
||||
int len;
|
||||
struct pci_controller *hose;
|
||||
char* disp_name;
|
||||
int *bus_range;
|
||||
int primary = 1;
|
||||
struct property *of_prop;
|
||||
|
||||
DBG("Adding PCI host bridge %s\n", dev->full_name);
|
||||
|
||||
bus_range = (int *) get_property(dev, "bus-range", &len);
|
||||
if (bus_range == NULL || len < 2 * sizeof(int)) {
|
||||
printk(KERN_WARNING "Can't get bus-range for %s, assume bus 0\n",
|
||||
dev->full_name);
|
||||
}
|
||||
|
||||
hose = alloc_bootmem(sizeof(struct pci_controller));
|
||||
if (hose == NULL)
|
||||
return -ENOMEM;
|
||||
pci_setup_pci_controller(hose);
|
||||
|
||||
hose->arch_data = dev;
|
||||
hose->first_busno = bus_range ? bus_range[0] : 0;
|
||||
hose->last_busno = bus_range ? bus_range[1] : 0xff;
|
||||
|
||||
of_prop = alloc_bootmem(sizeof(struct property) +
|
||||
sizeof(hose->global_number));
|
||||
if (of_prop) {
|
||||
memset(of_prop, 0, sizeof(struct property));
|
||||
of_prop->name = "linux,pci-domain";
|
||||
of_prop->length = sizeof(hose->global_number);
|
||||
of_prop->value = (unsigned char *)&of_prop[1];
|
||||
memcpy(of_prop->value, &hose->global_number, sizeof(hose->global_number));
|
||||
prom_add_property(dev, of_prop);
|
||||
}
|
||||
|
||||
disp_name = NULL;
|
||||
if (device_is_compatible(dev, "u3-agp")) {
|
||||
setup_u3_agp(hose);
|
||||
disp_name = "U3-AGP";
|
||||
primary = 0;
|
||||
} else if (device_is_compatible(dev, "u3-ht")) {
|
||||
setup_u3_ht(hose);
|
||||
disp_name = "U3-HT";
|
||||
primary = 1;
|
||||
}
|
||||
printk(KERN_INFO "Found %s PCI host bridge. Firmware bus number: %d->%d\n",
|
||||
disp_name, hose->first_busno, hose->last_busno);
|
||||
|
||||
/* Interpret the "ranges" property */
|
||||
/* This also maps the I/O region and sets isa_io/mem_base */
|
||||
pmac_process_bridge_OF_ranges(hose, dev, primary);
|
||||
|
||||
/* Fixup "bus-range" OF property */
|
||||
fixup_bus_range(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* We use our own read_irq_line here because PCI_INTERRUPT_PIN is
|
||||
* crap on some of Apple ASICs. We unconditionally use the Open Firmware
|
||||
* interrupt number as this is always right.
|
||||
*/
|
||||
static int pmac_pci_read_irq_line(struct pci_dev *pci_dev)
|
||||
{
|
||||
struct device_node *node;
|
||||
|
||||
node = pci_device_to_OF_node(pci_dev);
|
||||
if (node == NULL)
|
||||
return -1;
|
||||
if (node->n_intrs == 0)
|
||||
return -1;
|
||||
pci_dev->irq = node->intrs[0].line;
|
||||
pci_write_config_byte(pci_dev, PCI_INTERRUPT_LINE, pci_dev->irq);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void __init pmac_pcibios_fixup(void)
|
||||
{
|
||||
struct pci_dev *dev = NULL;
|
||||
|
||||
for_each_pci_dev(dev)
|
||||
pmac_pci_read_irq_line(dev);
|
||||
}
|
||||
|
||||
static void __init pmac_fixup_phb_resources(void)
|
||||
{
|
||||
struct pci_controller *hose, *tmp;
|
||||
|
||||
list_for_each_entry_safe(hose, tmp, &hose_list, list_node) {
|
||||
unsigned long offset = (unsigned long)hose->io_base_virt - pci_io_base;
|
||||
hose->io_resource.start += offset;
|
||||
hose->io_resource.end += offset;
|
||||
printk(KERN_INFO "PCI Host %d, io start: %lx; io end: %lx\n",
|
||||
hose->global_number,
|
||||
hose->io_resource.start, hose->io_resource.end);
|
||||
}
|
||||
}
|
||||
|
||||
void __init pmac_pci_init(void)
|
||||
{
|
||||
struct device_node *np, *root;
|
||||
struct device_node *ht = NULL;
|
||||
|
||||
/* Probe root PCI hosts, that is on U3 the AGP host and the
|
||||
* HyperTransport host. That one is actually "kept" around
|
||||
* and actually added last as it's resource management relies
|
||||
* on the AGP resources to have been setup first
|
||||
*/
|
||||
root = of_find_node_by_path("/");
|
||||
if (root == NULL) {
|
||||
printk(KERN_CRIT "pmac_find_bridges: can't find root of device tree\n");
|
||||
return;
|
||||
}
|
||||
for (np = NULL; (np = of_get_next_child(root, np)) != NULL;) {
|
||||
if (np->name == NULL)
|
||||
continue;
|
||||
if (strcmp(np->name, "pci") == 0) {
|
||||
if (add_bridge(np) == 0)
|
||||
of_node_get(np);
|
||||
}
|
||||
if (strcmp(np->name, "ht") == 0) {
|
||||
of_node_get(np);
|
||||
ht = np;
|
||||
}
|
||||
}
|
||||
of_node_put(root);
|
||||
|
||||
/* Now setup the HyperTransport host if we found any
|
||||
*/
|
||||
if (ht && add_bridge(ht) != 0)
|
||||
of_node_put(ht);
|
||||
|
||||
/* Fixup the IO resources on our host bridges as the common code
|
||||
* does it only for childs of the host bridges
|
||||
*/
|
||||
pmac_fixup_phb_resources();
|
||||
|
||||
/* Setup the linkage between OF nodes and PHBs */
|
||||
pci_devs_phb_init();
|
||||
|
||||
/* Fixup the PCI<->OF mapping for U3 AGP due to bus renumbering. We
|
||||
* assume there is no P2P bridge on the AGP bus, which should be a
|
||||
* safe assumptions hopefully.
|
||||
*/
|
||||
if (u3_agp) {
|
||||
struct device_node *np = u3_agp->arch_data;
|
||||
PCI_DN(np)->busno = 0xf0;
|
||||
for (np = np->child; np; np = np->sibling)
|
||||
PCI_DN(np)->busno = 0xf0;
|
||||
}
|
||||
|
||||
pmac_check_ht_link();
|
||||
|
||||
/* Tell pci.c to not use the common resource allocation mecanism */
|
||||
pci_probe_only = 1;
|
||||
|
||||
/* Allow all IO */
|
||||
io_page_mask = -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Disable second function on K2-SATA, it's broken
|
||||
* and disable IO BARs on first one
|
||||
*/
|
||||
static void fixup_k2_sata(struct pci_dev* dev)
|
||||
{
|
||||
int i;
|
||||
u16 cmd;
|
||||
|
||||
if (PCI_FUNC(dev->devfn) > 0) {
|
||||
pci_read_config_word(dev, PCI_COMMAND, &cmd);
|
||||
cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
|
||||
pci_write_config_word(dev, PCI_COMMAND, cmd);
|
||||
for (i = 0; i < 6; i++) {
|
||||
dev->resource[i].start = dev->resource[i].end = 0;
|
||||
dev->resource[i].flags = 0;
|
||||
pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, 0);
|
||||
}
|
||||
} else {
|
||||
pci_read_config_word(dev, PCI_COMMAND, &cmd);
|
||||
cmd &= ~PCI_COMMAND_IO;
|
||||
pci_write_config_word(dev, PCI_COMMAND, cmd);
|
||||
for (i = 0; i < 5; i++) {
|
||||
dev->resource[i].start = dev->resource[i].end = 0;
|
||||
dev->resource[i].flags = 0;
|
||||
pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS, 0x0240, fixup_k2_sata);
|
||||
|
|
@ -1,476 +0,0 @@
|
|||
/*
|
||||
* arch/ppc/platforms/setup.c
|
||||
*
|
||||
* PowerPC version
|
||||
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
||||
*
|
||||
* Adapted for Power Macintosh by Paul Mackerras
|
||||
* Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
|
||||
*
|
||||
* Derived from "arch/alpha/kernel/setup.c"
|
||||
* Copyright (C) 1995 Linus Torvalds
|
||||
*
|
||||
* Maintained by Benjamin Herrenschmidt (benh@kernel.crashing.org)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* bootup setup stuff..
|
||||
*/
|
||||
|
||||
#undef DEBUG
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/stddef.h>
|
||||
#include <linux/unistd.h>
|
||||
#include <linux/ptrace.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/user.h>
|
||||
#include <linux/a.out.h>
|
||||
#include <linux/tty.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/ioport.h>
|
||||
#include <linux/major.h>
|
||||
#include <linux/initrd.h>
|
||||
#include <linux/vt_kern.h>
|
||||
#include <linux/console.h>
|
||||
#include <linux/ide.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/adb.h>
|
||||
#include <linux/cuda.h>
|
||||
#include <linux/pmu.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/root_dev.h>
|
||||
#include <linux/bitops.h>
|
||||
|
||||
#include <asm/processor.h>
|
||||
#include <asm/sections.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/pci-bridge.h>
|
||||
#include <asm/iommu.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/dma.h>
|
||||
#include <asm/btext.h>
|
||||
#include <asm/cputable.h>
|
||||
#include <asm/pmac_feature.h>
|
||||
#include <asm/time.h>
|
||||
#include <asm/of_device.h>
|
||||
#include <asm/lmb.h>
|
||||
#include <asm/smu.h>
|
||||
#include <asm/pmc.h>
|
||||
#include <asm/mpic.h>
|
||||
#include <asm/udbg.h>
|
||||
|
||||
#include "pmac.h"
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DBG(fmt...) udbg_printf(fmt)
|
||||
#else
|
||||
#define DBG(fmt...)
|
||||
#endif
|
||||
|
||||
static int current_root_goodness = -1;
|
||||
#define DEFAULT_ROOT_DEVICE Root_SDA1 /* sda1 - slightly silly choice */
|
||||
|
||||
extern int powersave_nap;
|
||||
int sccdbg;
|
||||
|
||||
sys_ctrler_t sys_ctrler;
|
||||
EXPORT_SYMBOL(sys_ctrler);
|
||||
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
unsigned long smu_cmdbuf_abs;
|
||||
EXPORT_SYMBOL(smu_cmdbuf_abs);
|
||||
#endif
|
||||
|
||||
extern void udbg_init_scc(struct device_node *np);
|
||||
|
||||
static void 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 void __init pmac_setup_arch(void)
|
||||
{
|
||||
/* init to some ~sane value until calibrate_delay() runs */
|
||||
loops_per_jiffy = 50000000;
|
||||
|
||||
/* Probe motherboard chipset */
|
||||
pmac_feature_init();
|
||||
#if 0
|
||||
/* Lock-enable the SCC channel used for debug */
|
||||
if (sccdbg) {
|
||||
np = of_find_node_by_name(NULL, "escc");
|
||||
if (np)
|
||||
pmac_call_feature(PMAC_FTR_SCC_ENABLE, np,
|
||||
PMAC_SCC_ASYNC | PMAC_SCC_FLAG_XMON, 1);
|
||||
}
|
||||
#endif
|
||||
/* We can NAP */
|
||||
powersave_nap = 1;
|
||||
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
/* Initialize the PMU if any */
|
||||
find_via_pmu();
|
||||
#endif
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
/* Initialize the SMU if any */
|
||||
smu_init();
|
||||
#endif
|
||||
|
||||
/* Init NVRAM access */
|
||||
pmac_nvram_init();
|
||||
|
||||
/* Setup SMP callback */
|
||||
#ifdef CONFIG_SMP
|
||||
pmac_setup_smp();
|
||||
#endif
|
||||
|
||||
/* Lookup PCI hosts */
|
||||
pmac_pci_init();
|
||||
|
||||
#ifdef CONFIG_DUMMY_CONSOLE
|
||||
conswitchp = &dummy_con;
|
||||
#endif
|
||||
|
||||
printk(KERN_INFO "Using native/NAP idle loop\n");
|
||||
}
|
||||
|
||||
#ifdef CONFIG_SCSI
|
||||
void note_scsi_host(struct device_node *node, void *host)
|
||||
{
|
||||
/* Obsolete */
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
static int initializing = 1;
|
||||
|
||||
static int pmac_late_init(void)
|
||||
{
|
||||
initializing = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
late_initcall(pmac_late_init);
|
||||
|
||||
/* can't be __init - can be called whenever a disk is first accessed */
|
||||
void note_bootable_part(dev_t dev, int part, int goodness)
|
||||
{
|
||||
extern dev_t boot_dev;
|
||||
char *p;
|
||||
|
||||
if (!initializing)
|
||||
return;
|
||||
if ((goodness <= current_root_goodness) &&
|
||||
ROOT_DEV != DEFAULT_ROOT_DEVICE)
|
||||
return;
|
||||
p = strstr(saved_command_line, "root=");
|
||||
if (p != NULL && (p == saved_command_line || p[-1] == ' '))
|
||||
return;
|
||||
|
||||
if (!boot_dev || dev == boot_dev) {
|
||||
ROOT_DEV = dev + part;
|
||||
boot_dev = 0;
|
||||
current_root_goodness = goodness;
|
||||
}
|
||||
}
|
||||
|
||||
static void pmac_restart(char *cmd)
|
||||
{
|
||||
switch(sys_ctrler) {
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
case SYS_CTRLER_PMU:
|
||||
pmu_restart();
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
case SYS_CTRLER_SMU:
|
||||
smu_restart();
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
static void pmac_power_off(void)
|
||||
{
|
||||
switch(sys_ctrler) {
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
case SYS_CTRLER_PMU:
|
||||
pmu_shutdown();
|
||||
break;
|
||||
#endif
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
case SYS_CTRLER_SMU:
|
||||
smu_shutdown();
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
static void pmac_halt(void)
|
||||
{
|
||||
pmac_power_off();
|
||||
}
|
||||
|
||||
/*
|
||||
* Early initialization.
|
||||
*/
|
||||
static void __init pmac_init_early(void)
|
||||
{
|
||||
DBG(" -> pmac_init_early\n");
|
||||
|
||||
/* Initialize hash table, from now on, we can take hash faults
|
||||
* and call ioremap
|
||||
*/
|
||||
hpte_init_native();
|
||||
|
||||
/* Init SCC */
|
||||
if (strstr(cmd_line, "sccdbg")) {
|
||||
sccdbg = 1;
|
||||
udbg_init_scc(NULL);
|
||||
}
|
||||
|
||||
/* Setup interrupt mapping options */
|
||||
ppc64_interrupt_controller = IC_OPEN_PIC;
|
||||
|
||||
iommu_init_early_u3();
|
||||
|
||||
DBG(" <- pmac_init_early\n");
|
||||
}
|
||||
|
||||
static int pmac_u3_cascade(struct pt_regs *regs, void *data)
|
||||
{
|
||||
return mpic_get_one_irq((struct mpic *)data, regs);
|
||||
}
|
||||
|
||||
static __init void pmac_init_IRQ(void)
|
||||
{
|
||||
struct device_node *irqctrler = NULL;
|
||||
struct device_node *irqctrler2 = NULL;
|
||||
struct device_node *np = NULL;
|
||||
struct mpic *mpic1, *mpic2;
|
||||
|
||||
/* We first try to detect Apple's new Core99 chipset, since mac-io
|
||||
* is quite different on those machines and contains an IBM MPIC2.
|
||||
*/
|
||||
while ((np = of_find_node_by_type(np, "open-pic")) != NULL) {
|
||||
struct device_node *parent = of_get_parent(np);
|
||||
if (parent && !strcmp(parent->name, "u3"))
|
||||
irqctrler2 = of_node_get(np);
|
||||
else
|
||||
irqctrler = of_node_get(np);
|
||||
of_node_put(parent);
|
||||
}
|
||||
if (irqctrler != NULL && irqctrler->n_addrs > 0) {
|
||||
unsigned char senses[128];
|
||||
|
||||
printk(KERN_INFO "PowerMac using OpenPIC irq controller at 0x%08x\n",
|
||||
(unsigned int)irqctrler->addrs[0].address);
|
||||
|
||||
prom_get_irq_senses(senses, 0, 128);
|
||||
mpic1 = mpic_alloc(irqctrler->addrs[0].address,
|
||||
MPIC_PRIMARY | MPIC_WANTS_RESET,
|
||||
0, 0, 128, 256, senses, 128, " K2-MPIC ");
|
||||
BUG_ON(mpic1 == NULL);
|
||||
mpic_init(mpic1);
|
||||
|
||||
if (irqctrler2 != NULL && irqctrler2->n_intrs > 0 &&
|
||||
irqctrler2->n_addrs > 0) {
|
||||
printk(KERN_INFO "Slave OpenPIC at 0x%08x hooked on IRQ %d\n",
|
||||
(u32)irqctrler2->addrs[0].address,
|
||||
irqctrler2->intrs[0].line);
|
||||
|
||||
pmac_call_feature(PMAC_FTR_ENABLE_MPIC, irqctrler2, 0, 0);
|
||||
prom_get_irq_senses(senses, 128, 128 + 128);
|
||||
|
||||
/* We don't need to set MPIC_BROKEN_U3 here since we don't have
|
||||
* hypertransport interrupts routed to it
|
||||
*/
|
||||
mpic2 = mpic_alloc(irqctrler2->addrs[0].address,
|
||||
MPIC_BIG_ENDIAN | MPIC_WANTS_RESET,
|
||||
0, 128, 128, 0, senses, 128, " U3-MPIC ");
|
||||
BUG_ON(mpic2 == NULL);
|
||||
mpic_init(mpic2);
|
||||
mpic_setup_cascade(irqctrler2->intrs[0].line,
|
||||
pmac_u3_cascade, mpic2);
|
||||
}
|
||||
}
|
||||
of_node_put(irqctrler);
|
||||
of_node_put(irqctrler2);
|
||||
}
|
||||
|
||||
static void __init pmac_progress(char *s, unsigned short hex)
|
||||
{
|
||||
if (sccdbg) {
|
||||
udbg_puts(s);
|
||||
udbg_puts("\n");
|
||||
}
|
||||
#ifdef CONFIG_BOOTX_TEXT
|
||||
else if (boot_text_mapped) {
|
||||
btext_drawstring(s);
|
||||
btext_drawstring("\n");
|
||||
}
|
||||
#endif /* CONFIG_BOOTX_TEXT */
|
||||
}
|
||||
|
||||
/*
|
||||
* pmac has no legacy IO, anything calling this function has to
|
||||
* fail or bad things will happen
|
||||
*/
|
||||
static int pmac_check_legacy_ioport(unsigned int baseport)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static int __init pmac_declare_of_platform_devices(void)
|
||||
{
|
||||
struct device_node *np, *npp;
|
||||
|
||||
npp = of_find_node_by_name(NULL, "u3");
|
||||
if (npp) {
|
||||
for (np = NULL; (np = of_get_next_child(npp, np)) != NULL;) {
|
||||
if (strncmp(np->name, "i2c", 3) == 0) {
|
||||
of_platform_device_create(np, "u3-i2c", NULL);
|
||||
of_node_put(np);
|
||||
break;
|
||||
}
|
||||
}
|
||||
of_node_put(npp);
|
||||
}
|
||||
npp = of_find_node_by_type(NULL, "smu");
|
||||
if (npp) {
|
||||
of_platform_device_create(npp, "smu", NULL);
|
||||
of_node_put(npp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
device_initcall(pmac_declare_of_platform_devices);
|
||||
|
||||
/*
|
||||
* Called very early, MMU is off, device-tree isn't unflattened
|
||||
*/
|
||||
static int __init pmac_probe(int platform)
|
||||
{
|
||||
if (platform != PLATFORM_POWERMAC)
|
||||
return 0;
|
||||
/*
|
||||
* On U3, the DART (iommu) must be allocated now since it
|
||||
* has an impact on htab_initialize (due to the large page it
|
||||
* occupies having to be broken up so the DART itself is not
|
||||
* part of the cacheable linar mapping
|
||||
*/
|
||||
alloc_u3_dart_table();
|
||||
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
/*
|
||||
* SMU based G5s need some memory below 2Gb, at least the current
|
||||
* driver needs that. We have to allocate it now. We allocate 4k
|
||||
* (1 small page) for now.
|
||||
*/
|
||||
smu_cmdbuf_abs = lmb_alloc_base(4096, 4096, 0x80000000UL);
|
||||
#endif /* CONFIG_PMAC_SMU */
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int pmac_probe_mode(struct pci_bus *bus)
|
||||
{
|
||||
struct device_node *node = bus->sysdata;
|
||||
|
||||
/* We need to use normal PCI probing for the AGP bus,
|
||||
since the device for the AGP bridge isn't in the tree. */
|
||||
if (bus->self == NULL && device_is_compatible(node, "u3-agp"))
|
||||
return PCI_PROBE_NORMAL;
|
||||
|
||||
return PCI_PROBE_DEVTREE;
|
||||
}
|
||||
|
||||
struct machdep_calls __initdata pmac_md = {
|
||||
#ifdef CONFIG_HOTPLUG_CPU
|
||||
.cpu_die = generic_mach_cpu_die,
|
||||
#endif
|
||||
.probe = pmac_probe,
|
||||
.setup_arch = pmac_setup_arch,
|
||||
.init_early = pmac_init_early,
|
||||
.show_cpuinfo = pmac_show_cpuinfo,
|
||||
.init_IRQ = pmac_init_IRQ,
|
||||
.get_irq = mpic_get_irq,
|
||||
.pcibios_fixup = pmac_pcibios_fixup,
|
||||
.pci_probe_mode = pmac_probe_mode,
|
||||
.restart = pmac_restart,
|
||||
.power_off = pmac_power_off,
|
||||
.halt = pmac_halt,
|
||||
.get_boot_time = pmac_get_boot_time,
|
||||
.set_rtc_time = pmac_set_rtc_time,
|
||||
.get_rtc_time = pmac_get_rtc_time,
|
||||
.calibrate_decr = pmac_calibrate_decr,
|
||||
.feature_call = pmac_do_feature_call,
|
||||
.progress = pmac_progress,
|
||||
.check_legacy_ioport = pmac_check_legacy_ioport,
|
||||
.idle_loop = native_idle,
|
||||
.enable_pmcs = power4_enable_pmcs,
|
||||
};
|
|
@ -1,316 +0,0 @@
|
|||
/*
|
||||
* SMP support for power macintosh.
|
||||
*
|
||||
* We support both the old "powersurge" SMP architecture
|
||||
* and the current Core99 (G4 PowerMac) machines.
|
||||
*
|
||||
* Note that we don't support the very first rev. of
|
||||
* Apple/DayStar 2 CPUs board, the one with the funky
|
||||
* watchdog. Hopefully, none of these should be there except
|
||||
* maybe internally to Apple. I should probably still add some
|
||||
* code to detect this card though and disable SMP. --BenH.
|
||||
*
|
||||
* Support Macintosh G4 SMP by Troy Benjegerdes (hozer@drgw.net)
|
||||
* and Ben Herrenschmidt <benh@kernel.crashing.org>.
|
||||
*
|
||||
* Support for DayStar quad CPU cards
|
||||
* Copyright (C) XLR8, Inc. 1994-2000
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version
|
||||
* 2 of the License, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#undef DEBUG
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/smp.h>
|
||||
#include <linux/smp_lock.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/kernel_stat.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/irq.h>
|
||||
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <asm/irq.h>
|
||||
#include <asm/page.h>
|
||||
#include <asm/pgtable.h>
|
||||
#include <asm/sections.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/smp.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/pmac_feature.h>
|
||||
#include <asm/time.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm/keylargo.h>
|
||||
#include <asm/pmac_low_i2c.h>
|
||||
#include <asm/mpic.h>
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DBG(fmt...) udbg_printf(fmt)
|
||||
#else
|
||||
#define DBG(fmt...)
|
||||
#endif
|
||||
|
||||
extern void __secondary_start_pmac_0(void);
|
||||
|
||||
extern struct smp_ops_t *smp_ops;
|
||||
|
||||
static void (*pmac_tb_freeze)(int freeze);
|
||||
static struct device_node *pmac_tb_clock_chip_host;
|
||||
static u8 pmac_tb_pulsar_addr;
|
||||
static DEFINE_SPINLOCK(timebase_lock);
|
||||
static unsigned long timebase;
|
||||
|
||||
static void smp_core99_cypress_tb_freeze(int freeze)
|
||||
{
|
||||
u8 data;
|
||||
int rc;
|
||||
|
||||
/* Strangely, the device-tree says address is 0xd2, but darwin
|
||||
* accesses 0xd0 ...
|
||||
*/
|
||||
pmac_low_i2c_setmode(pmac_tb_clock_chip_host, pmac_low_i2c_mode_combined);
|
||||
rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host,
|
||||
0xd0 | pmac_low_i2c_read,
|
||||
0x81, &data, 1);
|
||||
if (rc != 0)
|
||||
goto bail;
|
||||
|
||||
data = (data & 0xf3) | (freeze ? 0x00 : 0x0c);
|
||||
|
||||
pmac_low_i2c_setmode(pmac_tb_clock_chip_host, pmac_low_i2c_mode_stdsub);
|
||||
rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host,
|
||||
0xd0 | pmac_low_i2c_write,
|
||||
0x81, &data, 1);
|
||||
|
||||
bail:
|
||||
if (rc != 0) {
|
||||
printk("Cypress Timebase %s rc: %d\n",
|
||||
freeze ? "freeze" : "unfreeze", rc);
|
||||
panic("Timebase freeze failed !\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void smp_core99_pulsar_tb_freeze(int freeze)
|
||||
{
|
||||
u8 data;
|
||||
int rc;
|
||||
|
||||
pmac_low_i2c_setmode(pmac_tb_clock_chip_host, pmac_low_i2c_mode_combined);
|
||||
rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host,
|
||||
pmac_tb_pulsar_addr | pmac_low_i2c_read,
|
||||
0x2e, &data, 1);
|
||||
if (rc != 0)
|
||||
goto bail;
|
||||
|
||||
data = (data & 0x88) | (freeze ? 0x11 : 0x22);
|
||||
|
||||
pmac_low_i2c_setmode(pmac_tb_clock_chip_host, pmac_low_i2c_mode_stdsub);
|
||||
rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host,
|
||||
pmac_tb_pulsar_addr | pmac_low_i2c_write,
|
||||
0x2e, &data, 1);
|
||||
bail:
|
||||
if (rc != 0) {
|
||||
printk(KERN_ERR "Pulsar Timebase %s rc: %d\n",
|
||||
freeze ? "freeze" : "unfreeze", rc);
|
||||
panic("Timebase freeze failed !\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void smp_core99_give_timebase(void)
|
||||
{
|
||||
/* Open i2c bus for synchronous access */
|
||||
if (pmac_low_i2c_open(pmac_tb_clock_chip_host, 0))
|
||||
panic("Can't open i2c for TB sync !\n");
|
||||
|
||||
spin_lock(&timebase_lock);
|
||||
(*pmac_tb_freeze)(1);
|
||||
mb();
|
||||
timebase = get_tb();
|
||||
spin_unlock(&timebase_lock);
|
||||
|
||||
while (timebase)
|
||||
barrier();
|
||||
|
||||
spin_lock(&timebase_lock);
|
||||
(*pmac_tb_freeze)(0);
|
||||
spin_unlock(&timebase_lock);
|
||||
|
||||
/* Close i2c bus */
|
||||
pmac_low_i2c_close(pmac_tb_clock_chip_host);
|
||||
}
|
||||
|
||||
|
||||
static void __devinit smp_core99_take_timebase(void)
|
||||
{
|
||||
while (!timebase)
|
||||
barrier();
|
||||
spin_lock(&timebase_lock);
|
||||
set_tb(timebase >> 32, timebase & 0xffffffff);
|
||||
timebase = 0;
|
||||
spin_unlock(&timebase_lock);
|
||||
}
|
||||
|
||||
|
||||
static int __init smp_core99_probe(void)
|
||||
{
|
||||
struct device_node *cpus;
|
||||
struct device_node *cc;
|
||||
int ncpus = 0;
|
||||
|
||||
/* Maybe use systemconfiguration here ? */
|
||||
if (ppc_md.progress) ppc_md.progress("smp_core99_probe", 0x345);
|
||||
|
||||
/* Count CPUs in the device-tree */
|
||||
for (cpus = NULL; (cpus = of_find_node_by_type(cpus, "cpu")) != NULL;)
|
||||
++ncpus;
|
||||
|
||||
printk(KERN_INFO "PowerMac SMP probe found %d cpus\n", ncpus);
|
||||
|
||||
/* Nothing more to do if less than 2 of them */
|
||||
if (ncpus <= 1)
|
||||
return 1;
|
||||
|
||||
/* HW sync only on these platforms */
|
||||
if (!machine_is_compatible("PowerMac7,2") &&
|
||||
!machine_is_compatible("PowerMac7,3") &&
|
||||
!machine_is_compatible("RackMac3,1"))
|
||||
goto nohwsync;
|
||||
|
||||
/* Look for the clock chip */
|
||||
for (cc = NULL; (cc = of_find_node_by_name(cc, "i2c-hwclock")) != NULL;) {
|
||||
struct device_node *p = of_get_parent(cc);
|
||||
u32 *reg;
|
||||
int ok;
|
||||
ok = p && device_is_compatible(p, "uni-n-i2c");
|
||||
if (!ok)
|
||||
goto next;
|
||||
reg = (u32 *)get_property(cc, "reg", NULL);
|
||||
if (reg == NULL)
|
||||
goto next;
|
||||
switch (*reg) {
|
||||
case 0xd2:
|
||||
if (device_is_compatible(cc, "pulsar-legacy-slewing")) {
|
||||
pmac_tb_freeze = smp_core99_pulsar_tb_freeze;
|
||||
pmac_tb_pulsar_addr = 0xd2;
|
||||
printk(KERN_INFO "Timebase clock is Pulsar chip\n");
|
||||
} else if (device_is_compatible(cc, "cy28508")) {
|
||||
pmac_tb_freeze = smp_core99_cypress_tb_freeze;
|
||||
printk(KERN_INFO "Timebase clock is Cypress chip\n");
|
||||
}
|
||||
break;
|
||||
case 0xd4:
|
||||
pmac_tb_freeze = smp_core99_pulsar_tb_freeze;
|
||||
pmac_tb_pulsar_addr = 0xd4;
|
||||
printk(KERN_INFO "Timebase clock is Pulsar chip\n");
|
||||
break;
|
||||
}
|
||||
if (pmac_tb_freeze != NULL) {
|
||||
pmac_tb_clock_chip_host = p;
|
||||
smp_ops->give_timebase = smp_core99_give_timebase;
|
||||
smp_ops->take_timebase = smp_core99_take_timebase;
|
||||
of_node_put(cc);
|
||||
of_node_put(p);
|
||||
break;
|
||||
}
|
||||
next:
|
||||
of_node_put(p);
|
||||
}
|
||||
|
||||
nohwsync:
|
||||
mpic_request_ipis();
|
||||
|
||||
return ncpus;
|
||||
}
|
||||
|
||||
static void __init smp_core99_kick_cpu(int nr)
|
||||
{
|
||||
unsigned int save_vector, j;
|
||||
unsigned long new_vector;
|
||||
unsigned long flags;
|
||||
volatile unsigned int *vector
|
||||
= ((volatile unsigned int *)(KERNELBASE+0x100));
|
||||
|
||||
if (nr < 1 || nr > 3)
|
||||
return;
|
||||
if (ppc_md.progress) ppc_md.progress("smp_core99_kick_cpu", 0x346);
|
||||
|
||||
local_irq_save(flags);
|
||||
local_irq_disable();
|
||||
|
||||
/* Save reset vector */
|
||||
save_vector = *vector;
|
||||
|
||||
/* Setup fake reset vector that does
|
||||
* b __secondary_start_pmac_0 + nr*8 - KERNELBASE
|
||||
*/
|
||||
new_vector = (unsigned long) __secondary_start_pmac_0 + nr * 8;
|
||||
*vector = 0x48000002 + (new_vector - KERNELBASE);
|
||||
|
||||
/* flush data cache and inval instruction cache */
|
||||
flush_icache_range((unsigned long) vector, (unsigned long) vector + 4);
|
||||
|
||||
/* Put some life in our friend */
|
||||
pmac_call_feature(PMAC_FTR_RESET_CPU, NULL, nr, 0);
|
||||
paca[nr].cpu_start = 1;
|
||||
|
||||
/* FIXME: We wait a bit for the CPU to take the exception, I should
|
||||
* instead wait for the entry code to set something for me. Well,
|
||||
* ideally, all that crap will be done in prom.c and the CPU left
|
||||
* in a RAM-based wait loop like CHRP.
|
||||
*/
|
||||
for (j = 1; j < 1000000; j++)
|
||||
mb();
|
||||
|
||||
/* Restore our exception vector */
|
||||
*vector = save_vector;
|
||||
flush_icache_range((unsigned long) vector, (unsigned long) vector + 4);
|
||||
|
||||
local_irq_restore(flags);
|
||||
if (ppc_md.progress) ppc_md.progress("smp_core99_kick_cpu done", 0x347);
|
||||
}
|
||||
|
||||
static void __init smp_core99_setup_cpu(int cpu_nr)
|
||||
{
|
||||
/* Setup MPIC */
|
||||
mpic_setup_this_cpu();
|
||||
|
||||
if (cpu_nr == 0) {
|
||||
extern void g5_phy_disable_cpu1(void);
|
||||
|
||||
/* If we didn't start the second CPU, we must take
|
||||
* it off the bus
|
||||
*/
|
||||
if (num_online_cpus() < 2)
|
||||
g5_phy_disable_cpu1();
|
||||
if (ppc_md.progress) ppc_md.progress("smp_core99_setup_cpu 0 done", 0x349);
|
||||
}
|
||||
}
|
||||
|
||||
struct smp_ops_t core99_smp_ops = {
|
||||
.message_pass = smp_mpic_message_pass,
|
||||
.probe = smp_core99_probe,
|
||||
.kick_cpu = smp_core99_kick_cpu,
|
||||
.setup_cpu = smp_core99_setup_cpu,
|
||||
.give_timebase = smp_generic_give_timebase,
|
||||
.take_timebase = smp_generic_take_timebase,
|
||||
};
|
||||
|
||||
void __init pmac_setup_smp(void)
|
||||
{
|
||||
smp_ops = &core99_smp_ops;
|
||||
#ifdef CONFIG_HOTPLUG_CPU
|
||||
smp_ops->cpu_enable = generic_cpu_enable;
|
||||
smp_ops->cpu_disable = generic_cpu_disable;
|
||||
smp_ops->cpu_die = generic_cpu_die;
|
||||
#endif
|
||||
}
|
|
@ -1,174 +0,0 @@
|
|||
/*
|
||||
* Support for periodic interrupts (100 per second) and for getting
|
||||
* the current time from the RTC on Power Macintoshes.
|
||||
*
|
||||
* We use the decrementer register for our periodic interrupts.
|
||||
*
|
||||
* Paul Mackerras August 1996.
|
||||
* Copyright (C) 1996 Paul Mackerras.
|
||||
* Copyright (C) 2003-2005 Benjamin Herrenschmidt.
|
||||
*
|
||||
*/
|
||||
#include <linux/config.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/param.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/time.h>
|
||||
#include <linux/adb.h>
|
||||
#include <linux/pmu.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/rtc.h>
|
||||
|
||||
#include <asm/sections.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/pgtable.h>
|
||||
#include <asm/machdep.h>
|
||||
#include <asm/time.h>
|
||||
#include <asm/nvram.h>
|
||||
#include <asm/smu.h>
|
||||
|
||||
#undef DEBUG
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DBG(x...) printk(x)
|
||||
#else
|
||||
#define DBG(x...)
|
||||
#endif
|
||||
|
||||
/* Apparently the RTC stores seconds since 1 Jan 1904 */
|
||||
#define RTC_OFFSET 2082844800
|
||||
|
||||
/*
|
||||
* Calibrate the decrementer frequency with the VIA timer 1.
|
||||
*/
|
||||
#define VIA_TIMER_FREQ_6 4700000 /* time 1 frequency * 6 */
|
||||
|
||||
extern struct timezone sys_tz;
|
||||
extern void to_tm(int tim, struct rtc_time * tm);
|
||||
|
||||
void pmac_get_rtc_time(struct rtc_time *tm)
|
||||
{
|
||||
switch(sys_ctrler) {
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
case SYS_CTRLER_PMU: {
|
||||
/* TODO: Move that to a function in the PMU driver */
|
||||
struct adb_request req;
|
||||
unsigned int now;
|
||||
|
||||
if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
|
||||
return;
|
||||
pmu_wait_complete(&req);
|
||||
if (req.reply_len != 4)
|
||||
printk(KERN_ERR "pmac_get_rtc_time: PMU returned a %d"
|
||||
" bytes reply\n", req.reply_len);
|
||||
now = (req.reply[0] << 24) + (req.reply[1] << 16)
|
||||
+ (req.reply[2] << 8) + req.reply[3];
|
||||
DBG("get: %u -> %u\n", (int)now, (int)(now - RTC_OFFSET));
|
||||
now -= RTC_OFFSET;
|
||||
|
||||
to_tm(now, tm);
|
||||
tm->tm_year -= 1900;
|
||||
tm->tm_mon -= 1;
|
||||
|
||||
DBG("-> tm_mday: %d, tm_mon: %d, tm_year: %d, %d:%02d:%02d\n",
|
||||
tm->tm_mday, tm->tm_mon, tm->tm_year,
|
||||
tm->tm_hour, tm->tm_min, tm->tm_sec);
|
||||
break;
|
||||
}
|
||||
#endif /* CONFIG_ADB_PMU */
|
||||
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
case SYS_CTRLER_SMU:
|
||||
smu_get_rtc_time(tm, 1);
|
||||
break;
|
||||
#endif /* CONFIG_PMAC_SMU */
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
int pmac_set_rtc_time(struct rtc_time *tm)
|
||||
{
|
||||
switch(sys_ctrler) {
|
||||
#ifdef CONFIG_ADB_PMU
|
||||
case SYS_CTRLER_PMU: {
|
||||
/* TODO: Move that to a function in the PMU driver */
|
||||
struct adb_request req;
|
||||
unsigned int nowtime;
|
||||
|
||||
DBG("set: tm_mday: %d, tm_mon: %d, tm_year: %d,"
|
||||
" %d:%02d:%02d\n",
|
||||
tm->tm_mday, tm->tm_mon, tm->tm_year,
|
||||
tm->tm_hour, tm->tm_min, tm->tm_sec);
|
||||
|
||||
nowtime = mktime(tm->tm_year + 1900, tm->tm_mon + 1,
|
||||
tm->tm_mday, tm->tm_hour, tm->tm_min,
|
||||
tm->tm_sec);
|
||||
|
||||
DBG("-> %u -> %u\n", (int)nowtime,
|
||||
(int)(nowtime + RTC_OFFSET));
|
||||
nowtime += RTC_OFFSET;
|
||||
|
||||
if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
|
||||
nowtime >> 24, nowtime >> 16,
|
||||
nowtime >> 8, nowtime) < 0)
|
||||
return -ENXIO;
|
||||
pmu_wait_complete(&req);
|
||||
if (req.reply_len != 0)
|
||||
printk(KERN_ERR "pmac_set_rtc_time: PMU returned a %d"
|
||||
" bytes reply\n", req.reply_len);
|
||||
return 0;
|
||||
}
|
||||
#endif /* CONFIG_ADB_PMU */
|
||||
|
||||
#ifdef CONFIG_PMAC_SMU
|
||||
case SYS_CTRLER_SMU:
|
||||
return smu_set_rtc_time(tm, 1);
|
||||
#endif /* CONFIG_PMAC_SMU */
|
||||
default:
|
||||
return -ENODEV;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned long __init pmac_get_boot_time(void)
|
||||
{
|
||||
struct rtc_time tm;
|
||||
|
||||
pmac_get_rtc_time(&tm);
|
||||
return mktime(tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
|
||||
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
||||
}
|
||||
|
||||
/*
|
||||
* Query the OF and get the decr frequency.
|
||||
* FIXME: merge this with generic_calibrate_decr
|
||||
*/
|
||||
void __init pmac_calibrate_decr(void)
|
||||
{
|
||||
struct device_node *cpu;
|
||||
unsigned int *fp;
|
||||
|
||||
/*
|
||||
* The cpu node should have a timebase-frequency property
|
||||
* to tell us the rate at which the decrementer counts.
|
||||
*/
|
||||
cpu = find_type_devices("cpu");
|
||||
if (cpu == 0)
|
||||
panic("can't find cpu node in time_init");
|
||||
fp = (unsigned int *) get_property(cpu, "timebase-frequency", NULL);
|
||||
if (fp == 0)
|
||||
panic("can't get cpu timebase frequency");
|
||||
ppc_tb_freq = *fp;
|
||||
|
||||
fp = (unsigned int *)get_property(cpu, "clock-frequency", NULL);
|
||||
if (fp == 0)
|
||||
panic("can't get cpu processor frequency");
|
||||
ppc_proc_freq = *fp;
|
||||
}
|
||||
|
Loading…
Reference in a new issue