[net-next-2.6.git] / arch / ppc / platforms / gemini_setup.c

/*
 *  Copyright (C) 1995 Linus Torvalds
 *  Adapted from 'alpha' version by Gary Thomas
 *  Modified by Cort Dougan (cort@cs.nmt.edu)
 *  Synergy Microsystems board support by Dan Cox (dan@synergymicro.com)
 *
 */

#include <linux/config.h>
#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/reboot.h>
#include <linux/pci.h>
#include <linux/time.h>
#include <linux/kdev_t.h>
#include <linux/types.h>
#include <linux/major.h>
#include <linux/initrd.h>
#include <linux/console.h>
#include <linux/seq_file.h>
#include <linux/root_dev.h>
#include <linux/bcd.h>

#include <asm/system.h>
#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/dma.h>
#include <asm/io.h>
#include <asm/m48t35.h>
#include <platforms/gemini.h>
#include <asm/time.h>
#include <asm/open_pic.h>
#include <asm/bootinfo.h>
#include <asm/machdep.h>

void gemini_find_bridges(void);
static int gemini_get_clock_speed(void);
extern void gemini_pcibios_fixup(void);

static char *gemini_board_families[] = {
  "VGM", "VSS", "KGM", "VGR", "VCM", "VCS", "KCM", "VCR"
};
static int gemini_board_count = sizeof(gemini_board_families) /
                                 sizeof(gemini_board_families[0]);

static unsigned int cpu_7xx[16] = {
	0, 15, 14, 0, 0, 13, 5, 9, 6, 11, 8, 10, 16, 12, 7, 0
};
static unsigned int cpu_6xx[16] = {
	0, 0, 14, 0, 0, 13, 5, 9, 6, 11, 8, 10, 0, 12, 7, 0
};

/*
 * prom_init is the Gemini version of prom.c:prom_init.  We only need
 * the BSS clearing code, so I copied that out of prom.c.  This is a
 * lot simpler than hacking prom.c so it will build with Gemini. -VAL
 */

#define PTRRELOC(x)	((typeof(x))((unsigned long)(x) + offset))

unsigned long
prom_init(void)
{
	unsigned long offset = reloc_offset();
	unsigned long phys;
	extern char __bss_start, _end;

	/* First zero the BSS -- use memset, some arches don't have
	 * caches on yet */
	memset_io(PTRRELOC(&__bss_start),0 , &_end - &__bss_start);

 	/* Default */
 	phys = offset + KERNELBASE;

	gemini_prom_init();

	return phys;
}

int
gemini_show_cpuinfo(struct seq_file *m)
{
	unsigned char reg, rev;
	char *family;
	unsigned int type;

	reg = readb(GEMINI_FEAT);
	family = gemini_board_families[((reg>>4) & 0xf)];
	if (((reg>>4) & 0xf) > gemini_board_count)
		printk(KERN_ERR "cpuinfo(): unable to determine board family\n");

	reg = readb(GEMINI_BREV);
	type = (reg>>4) & 0xf;
	rev = reg & 0xf;

	reg = readb(GEMINI_BECO);

	seq_printf(m, "machine\t\t: Gemini %s%d, rev %c, eco %d\n",
		   family, type, (rev + 'A'), (reg & 0xf));

	seq_printf(m, "board\t\t: Gemini %s", family);
	if (type > 9)
		seq_printf(m, "%c", (type - 10) + 'A');
	else
		seq_printf(m, "%d", type);

	seq_printf(m, ", rev %c, eco %d\n", (rev + 'A'), (reg & 0xf));

	seq_printf(m, "clock\t\t: %dMhz\n", gemini_get_clock_speed());

	return 0;
}

static u_char gemini_openpic_initsenses[] = {
	1,
	1,
	1,
	1,
	0,
	0,
	1, /* remainder are level-triggered */
};

#define GEMINI_MPIC_ADDR (0xfcfc0000)
#define GEMINI_MPIC_PCI_CFG (0x80005800)

void __init gemini_openpic_init(void)
{

	OpenPIC_Addr = (volatile struct OpenPIC *)
		grackle_read(GEMINI_MPIC_PCI_CFG + 0x10);
	OpenPIC_InitSenses = gemini_openpic_initsenses;
	OpenPIC_NumInitSenses = sizeof( gemini_openpic_initsenses );

	ioremap( GEMINI_MPIC_ADDR, OPENPIC_SIZE);
}


extern unsigned long loops_per_jiffy;
extern int root_mountflags;
extern char cmd_line[];

void
gemini_heartbeat(void)
{
	static unsigned long led = GEMINI_LEDBASE+(4*8);
	static char direction = 8;


	/* We only want to do this on 1 CPU */
	if (smp_processor_id())
		return;
	*(char *)led = 0;
	if ( (led + direction) > (GEMINI_LEDBASE+(7*8)) ||
	     (led + direction) < (GEMINI_LEDBASE+(4*8)) )
		direction *= -1;
	led += direction;
	*(char *)led = 0xff;
	ppc_md.heartbeat_count = ppc_md.heartbeat_reset;
}

void __init gemini_setup_arch(void)
{
	extern char cmd_line[];


	loops_per_jiffy = 50000000/HZ;

#ifdef CONFIG_BLK_DEV_INITRD
	/* bootable off CDROM */
	if (initrd_start)
		ROOT_DEV = Root_SR0;
	else
#endif
		ROOT_DEV = Root_SDA1;

	/* nothing but serial consoles... */
	sprintf(cmd_line, "%s console=ttyS0", cmd_line);

	printk("Boot arguments: %s\n", cmd_line);

	ppc_md.heartbeat = gemini_heartbeat;
	ppc_md.heartbeat_reset = HZ/8;
	ppc_md.heartbeat_count = 1;

	/* Lookup PCI hosts */
	gemini_find_bridges();
	/* take special pains to map the MPIC, since it isn't mapped yet */
	gemini_openpic_init();
	/* start the L2 */
	gemini_init_l2();
}


int
gemini_get_clock_speed(void)
{
	unsigned long hid1, pvr;
	int clock;

	pvr = mfspr(SPRN_PVR);
	hid1 = (mfspr(SPRN_HID1) >> 28) & 0xf;
	if (PVR_VER(pvr) == 8 ||
	    PVR_VER(pvr) == 12)
		hid1 = cpu_7xx[hid1];
	else
		hid1 = cpu_6xx[hid1];

	switch((readb(GEMINI_BSTAT) & 0xc) >> 2) {

	case 0:
	default:
		clock = (hid1*100)/3;
		break;

	case 1:
		clock = (hid1*125)/3;
		break;

	case 2:
		clock = (hid1*50);
		break;
	}

	return clock;
}

void __init gemini_init_l2(void)
{
        unsigned char reg, brev, fam, creg;
        unsigned long cache;
        unsigned long pvr;

        reg = readb(GEMINI_L2CFG);
        brev = readb(GEMINI_BREV);
        fam = readb(GEMINI_FEAT);
        pvr = mfspr(SPRN_PVR);

        switch(PVR_VER(pvr)) {

        case 8:
                if (reg & 0xc0)
                        cache = (((reg >> 6) & 0x3) << 28);
                else
                        cache = 0x3 << 28;

#ifdef CONFIG_SMP
                /* Pre-3.0 processor revs had snooping errata.  Leave
                   their L2's disabled with SMP. -- Dan */
                if (PVR_CFG(pvr) < 3) {
                        printk("Pre-3.0 750; L2 left disabled!\n");
                        return;
                }
#endif /* CONFIG_SMP */

                /* Special case: VGM5-B's came before L2 ratios were set on
                   the board.  Processor speed shouldn't be too high, so
                   set L2 ratio to 1:1.5.  */
                if ((brev == 0x51) && ((fam & 0xa0) >> 4) == 0)
                        reg |= 1;

                /* determine best cache ratio based upon what the board
                   tells us (which sometimes _may_ not be true) and
                   the processor speed. */
                else {
                        if (gemini_get_clock_speed() > 250)
                                reg = 2;
                }
                break;
        case 12:
	{
		static unsigned long l2_size_val = 0;

		if (!l2_size_val)
			l2_size_val = _get_L2CR();
		cache = l2_size_val;
                break;
	}
        case 4:
        case 9:
                creg = readb(GEMINI_CPUSTAT);
                if (((creg & 0xc) >> 2) != 1)
                        printk("Dual-604 boards don't support the use of L2\n");
                else
                        writeb(1, GEMINI_L2CFG);
                return;
        default:
                printk("Unknown processor; L2 left disabled\n");
                return;
        }

        cache |= ((1<<reg) << 25);
        cache |= (L2CR_L2RAM_MASK|L2CR_L2CTL|L2CR_L2DO);
        _set_L2CR(0);
        _set_L2CR(cache | L2CR_L2E);

}

void
gemini_restart(char *cmd)
{
	local_irq_disable();
	/* make a clean restart, not via the MPIC */
	_gemini_reboot();
	for(;;);
}

void
gemini_power_off(void)
{
	for(;;);
}

void
gemini_halt(void)
{
	gemini_restart(NULL);
}

void __init gemini_init_IRQ(void)
{
	/* gemini has no 8259 */
	openpic_init(1, 0, 0, -1);
}

#define gemini_rtc_read(x)       (readb(GEMINI_RTC+(x)))
#define gemini_rtc_write(val,x)  (writeb((val),(GEMINI_RTC+(x))))

/* ensure that the RTC is up and running */
long __init gemini_time_init(void)
{
	unsigned char reg;

	reg = gemini_rtc_read(M48T35_RTC_CONTROL);

	if ( reg & M48T35_RTC_STOPPED ) {
		printk(KERN_INFO "M48T35 real-time-clock was stopped. Now starting...\n");
		gemini_rtc_write((reg & ~(M48T35_RTC_STOPPED)), M48T35_RTC_CONTROL);
		gemini_rtc_write((reg | M48T35_RTC_SET), M48T35_RTC_CONTROL);
	}
	return 0;
}

#undef DEBUG_RTC

unsigned long
gemini_get_rtc_time(void)
{
	unsigned int year, mon, day, hour, min, sec;
	unsigned char reg;

	reg = gemini_rtc_read(M48T35_RTC_CONTROL);
	gemini_rtc_write((reg|M48T35_RTC_READ), M48T35_RTC_CONTROL);
#ifdef DEBUG_RTC
	printk("get rtc: reg = %x\n", reg);
#endif

	do {
		sec = gemini_rtc_read(M48T35_RTC_SECONDS);
		min = gemini_rtc_read(M48T35_RTC_MINUTES);
		hour = gemini_rtc_read(M48T35_RTC_HOURS);
		day = gemini_rtc_read(M48T35_RTC_DOM);
		mon = gemini_rtc_read(M48T35_RTC_MONTH);
		year = gemini_rtc_read(M48T35_RTC_YEAR);
	} while( sec != gemini_rtc_read(M48T35_RTC_SECONDS));
#ifdef DEBUG_RTC
	printk("get rtc: sec=%x, min=%x, hour=%x, day=%x, mon=%x, year=%x\n",
	       sec, min, hour, day, mon, year);
#endif

	gemini_rtc_write(reg, M48T35_RTC_CONTROL);

	BCD_TO_BIN(sec);
	BCD_TO_BIN(min);
	BCD_TO_BIN(hour);
	BCD_TO_BIN(day);
	BCD_TO_BIN(mon);
	BCD_TO_BIN(year);

	if ((year += 1900) < 1970)
		year += 100;
#ifdef DEBUG_RTC
	printk("get rtc: sec=%x, min=%x, hour=%x, day=%x, mon=%x, year=%x\n",
	       sec, min, hour, day, mon, year);
#endif

	return mktime( year, mon, day, hour, min, sec );
}


int
gemini_set_rtc_time( unsigned long now )
{
	unsigned char reg;
	struct rtc_time tm;

	to_tm( now, &tm );

	reg = gemini_rtc_read(M48T35_RTC_CONTROL);
#ifdef DEBUG_RTC
	printk("set rtc: reg = %x\n", reg);
#endif

	gemini_rtc_write((reg|M48T35_RTC_SET), M48T35_RTC_CONTROL);
#ifdef DEBUG_RTC
	printk("set rtc: tm vals - sec=%x, min=%x, hour=%x, mon=%x, mday=%x, year=%x\n",
	       tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mon, tm.tm_mday, tm.tm_year);
#endif

	tm.tm_year -= 1900;
	BIN_TO_BCD(tm.tm_sec);
	BIN_TO_BCD(tm.tm_min);
	BIN_TO_BCD(tm.tm_hour);
	BIN_TO_BCD(tm.tm_mon);
	BIN_TO_BCD(tm.tm_mday);
	BIN_TO_BCD(tm.tm_year);
#ifdef DEBUG_RTC
	printk("set rtc: tm vals - sec=%x, min=%x, hour=%x, mon=%x, mday=%x, year=%x\n",
	       tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mon, tm.tm_mday, tm.tm_year);
#endif

	gemini_rtc_write(tm.tm_sec, M48T35_RTC_SECONDS);
	gemini_rtc_write(tm.tm_min, M48T35_RTC_MINUTES);
	gemini_rtc_write(tm.tm_hour, M48T35_RTC_HOURS);
	gemini_rtc_write(tm.tm_mday, M48T35_RTC_DOM);
	gemini_rtc_write(tm.tm_mon, M48T35_RTC_MONTH);
	gemini_rtc_write(tm.tm_year, M48T35_RTC_YEAR);

	/* done writing */
	gemini_rtc_write(reg, M48T35_RTC_CONTROL);

	return 0;
}

/*  use the RTC to determine the decrementer count */
void __init gemini_calibrate_decr(void)
{
	int freq, divisor;
	unsigned char reg;

	/* determine processor bus speed */
	reg = readb(GEMINI_BSTAT);

	switch(((reg & 0x0c)>>2)&0x3) {
	case 0:
	default:
		freq = 66667;
		break;
	case 1:
		freq = 83000;
		break;
	case 2:
		freq = 100000;
		break;
	}

	freq *= 1000;
	divisor = 4;
	tb_ticks_per_jiffy = freq / HZ / divisor;
	tb_to_us = mulhwu_scale_factor(freq/divisor, 1000000);
}

unsigned long __init gemini_find_end_of_memory(void)
{
	unsigned long total;
	unsigned char reg;

	reg = readb(GEMINI_MEMCFG);
	total = ((1<<((reg & 0x7) - 1)) *
		 (8<<((reg >> 3) & 0x7)));
	total *= (1024*1024);
	return total;
}

static void __init
gemini_map_io(void)
{
	io_block_mapping(0xf0000000, 0xf0000000, 0x10000000, _PAGE_IO);
	io_block_mapping(0x80000000, 0x80000000, 0x10000000, _PAGE_IO);
}

#ifdef CONFIG_SMP
static int
smp_gemini_probe(void)
{
	int i, nr;

        nr = (readb(GEMINI_CPUSTAT) & GEMINI_CPU_COUNT_MASK) >> 2;
	if (nr == 0)
		nr = 4;

	if (nr > 1) {
		openpic_request_IPIs();
		for (i = 1; i < nr; ++i)
			smp_hw_index[i] = i;
	}

	return nr;
}

static void
smp_gemini_kick_cpu(int nr)
{
	openpic_reset_processor_phys(1 << nr);
	openpic_reset_processor_phys(0);
}

static void
smp_gemini_setup_cpu(int cpu_nr)
{
	if (OpenPIC_Addr)
		do_openpic_setup_cpu();
	if (cpu_nr > 0)
		gemini_init_l2();
}

static struct smp_ops_t gemini_smp_ops = {
	smp_openpic_message_pass,
	smp_gemini_probe,
	smp_gemini_kick_cpu,
	smp_gemini_setup_cpu,
	.give_timebase = smp_generic_give_timebase,
	.take_timebase = smp_generic_take_timebase,
};
#endif /* CONFIG_SMP */

void __init platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
			  unsigned long r6, unsigned long r7)
{
	int i;

	/* Restore BATs for now */
	mtspr(SPRN_DBAT3U, 0xf0001fff);
	mtspr(SPRN_DBAT3L, 0xf000002a);

	parse_bootinfo(find_bootinfo());

	for(i = 0; i < GEMINI_LEDS; i++)
		gemini_led_off(i);

	ISA_DMA_THRESHOLD = 0;
	DMA_MODE_READ = 0;
	DMA_MODE_WRITE = 0;

#ifdef CONFIG_BLK_DEV_INITRD
	if ( r4 )
	{
		initrd_start = r4 + KERNELBASE;
		initrd_end = r5 + KERNELBASE;
	}
#endif

	ppc_md.setup_arch = gemini_setup_arch;
	ppc_md.show_cpuinfo = gemini_show_cpuinfo;
	ppc_md.init_IRQ = gemini_init_IRQ;
	ppc_md.get_irq = openpic_get_irq;
	ppc_md.init = NULL;

	ppc_md.restart = gemini_restart;
	ppc_md.power_off = gemini_power_off;
	ppc_md.halt = gemini_halt;

	ppc_md.time_init = gemini_time_init;
	ppc_md.set_rtc_time = gemini_set_rtc_time;
	ppc_md.get_rtc_time = gemini_get_rtc_time;
	ppc_md.calibrate_decr = gemini_calibrate_decr;

	ppc_md.find_end_of_memory = gemini_find_end_of_memory;
	ppc_md.setup_io_mappings = gemini_map_io;

	ppc_md.pcibios_fixup_bus = gemini_pcibios_fixup;

#ifdef CONFIG_SMP
	smp_ops = &gemini_smp_ops;
#endif /* CONFIG_SMP */
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Copyright (C) 1995 Linus Torvalds
	3	* Adapted from 'alpha' version by Gary Thomas
	4	* Modified by Cort Dougan (cort@cs.nmt.edu)
	5	* Synergy Microsystems board support by Dan Cox (dan@synergymicro.com)
	6	*
	7	*/
	8
	9	#include <linux/config.h>
	10	#include <linux/stddef.h>
	11	#include <linux/kernel.h>
	12	#include <linux/init.h>
	13	#include <linux/errno.h>
	14	#include <linux/reboot.h>
	15	#include <linux/pci.h>
	16	#include <linux/time.h>
	17	#include <linux/kdev_t.h>
	18	#include <linux/types.h>
	19	#include <linux/major.h>
	20	#include <linux/initrd.h>
	21	#include <linux/console.h>
1da177e4 LT	22	#include <linux/seq_file.h>
	23	#include <linux/root_dev.h>
	24	#include <linux/bcd.h>
	25
	26	#include <asm/system.h>
	27	#include <asm/pgtable.h>
	28	#include <asm/page.h>
	29	#include <asm/dma.h>
	30	#include <asm/io.h>
	31	#include <asm/m48t35.h>
	32	#include <platforms/gemini.h>
	33	#include <asm/time.h>
	34	#include <asm/open_pic.h>
	35	#include <asm/bootinfo.h>
fd582ec8	36	#include <asm/machdep.h>
1da177e4 LT	37
	38	void gemini_find_bridges(void);
	39	static int gemini_get_clock_speed(void);
	40	extern void gemini_pcibios_fixup(void);
	41
	42	static char *gemini_board_families[] = {
	43	"VGM", "VSS", "KGM", "VGR", "VCM", "VCS", "KCM", "VCR"
	44	};
	45	static int gemini_board_count = sizeof(gemini_board_families) /
	46	sizeof(gemini_board_families[0]);
	47
	48	static unsigned int cpu_7xx[16] = {
	49	0, 15, 14, 0, 0, 13, 5, 9, 6, 11, 8, 10, 16, 12, 7, 0
	50	};
	51	static unsigned int cpu_6xx[16] = {
	52	0, 0, 14, 0, 0, 13, 5, 9, 6, 11, 8, 10, 0, 12, 7, 0
	53	};
	54
	55	/*
	56	* prom_init is the Gemini version of prom.c:prom_init. We only need
	57	* the BSS clearing code, so I copied that out of prom.c. This is a
	58	* lot simpler than hacking prom.c so it will build with Gemini. -VAL
	59	*/
	60
	61	#define PTRRELOC(x) ((typeof(x))((unsigned long)(x) + offset))
	62
	63	unsigned long
	64	prom_init(void)
	65	{
	66	unsigned long offset = reloc_offset();
	67	unsigned long phys;
	68	extern char __bss_start, _end;
	69
	70	/* First zero the BSS -- use memset, some arches don't have
	71	* caches on yet */
	72	memset_io(PTRRELOC(&__bss_start),0 , &_end - &__bss_start);
	73
	74	/* Default */
	75	phys = offset + KERNELBASE;
	76
	77	gemini_prom_init();
	78
	79	return phys;
	80	}
	81
	82	int
	83	gemini_show_cpuinfo(struct seq_file *m)
	84	{
	85	unsigned char reg, rev;
	86	char *family;
	87	unsigned int type;
	88
	89	reg = readb(GEMINI_FEAT);
	90	family = gemini_board_families[((reg>>4) & 0xf)];
	91	if (((reg>>4) & 0xf) > gemini_board_count)
	92	printk(KERN_ERR "cpuinfo(): unable to determine board family\n");
	93
	94	reg = readb(GEMINI_BREV);
	95	type = (reg>>4) & 0xf;
	96	rev = reg & 0xf;
	97
	98	reg = readb(GEMINI_BECO);
	99
	100	seq_printf(m, "machine\t\t: Gemini %s%d, rev %c, eco %d\n",
101	family, type, (rev + 'A'), (reg & 0xf));
102
103	seq_printf(m, "board\t\t: Gemini %s", family);
104	if (type > 9)
105	seq_printf(m, "%c", (type - 10) + 'A');
106	else
107	seq_printf(m, "%d", type);
108
109	seq_printf(m, ", rev %c, eco %d\n", (rev + 'A'), (reg & 0xf));
110
111	seq_printf(m, "clock\t\t: %dMhz\n", gemini_get_clock_speed());
112
113	return 0;
114	}
115
116	static u_char gemini_openpic_initsenses[] = {
117	1,
118	1,
119	1,
120	1,
121	0,
122	0,
123	1, /* remainder are level-triggered */
124	};
125
126	#define GEMINI_MPIC_ADDR (0xfcfc0000)
127	#define GEMINI_MPIC_PCI_CFG (0x80005800)
128
129	void __init gemini_openpic_init(void)
130	{
131
132	OpenPIC_Addr = (volatile struct OpenPIC *)
133	grackle_read(GEMINI_MPIC_PCI_CFG + 0x10);
134	OpenPIC_InitSenses = gemini_openpic_initsenses;
135	OpenPIC_NumInitSenses = sizeof( gemini_openpic_initsenses );
136
137	ioremap( GEMINI_MPIC_ADDR, OPENPIC_SIZE);
138	}
139
140
141	extern unsigned long loops_per_jiffy;
142	extern int root_mountflags;
143	extern char cmd_line[];
144
145	void
146	gemini_heartbeat(void)
147	{
148	static unsigned long led = GEMINI_LEDBASE+(4*8);
149	static char direction = 8;
150
151
152	/* We only want to do this on 1 CPU */
153	if (smp_processor_id())
154	return;
155	(char )led = 0;
156	if ( (led + direction) > (GEMINI_LEDBASE+(7*8)) \|\|
157	(led + direction) < (GEMINI_LEDBASE+(4*8)) )
158	direction *= -1;
159	led += direction;
160	(char )led = 0xff;
161	ppc_md.heartbeat_count = ppc_md.heartbeat_reset;
162	}
163
164	void __init gemini_setup_arch(void)
165	{
166	extern char cmd_line[];
167
168
169	loops_per_jiffy = 50000000/HZ;
170
171	#ifdef CONFIG_BLK_DEV_INITRD
172	/* bootable off CDROM */
173	if (initrd_start)
174	ROOT_DEV = Root_SR0;
175	else
176	#endif
177	ROOT_DEV = Root_SDA1;
178
179	/* nothing but serial consoles... */
180	sprintf(cmd_line, "%s console=ttyS0", cmd_line);
181
182	printk("Boot arguments: %s\n", cmd_line);
183
184	ppc_md.heartbeat = gemini_heartbeat;
185	ppc_md.heartbeat_reset = HZ/8;
186	ppc_md.heartbeat_count = 1;
187
188	/* Lookup PCI hosts */
189	gemini_find_bridges();
190	/* take special pains to map the MPIC, since it isn't mapped yet */
191	gemini_openpic_init();
192	/* start the L2 */
193	gemini_init_l2();
194	}
195
196
197	int
198	gemini_get_clock_speed(void)
199	{
200	unsigned long hid1, pvr;
201	int clock;
202
203	pvr = mfspr(SPRN_PVR);
204	hid1 = (mfspr(SPRN_HID1) >> 28) & 0xf;
205	if (PVR_VER(pvr) == 8 \|\|
206	PVR_VER(pvr) == 12)
207	hid1 = cpu_7xx[hid1];
208	else
209	hid1 = cpu_6xx[hid1];
210
211	switch((readb(GEMINI_BSTAT) & 0xc) >> 2) {
212
213	case 0:
214	default:
215	clock = (hid1*100)/3;
216	break;
217
218	case 1:
219	clock = (hid1*125)/3;
220	break;
221
222	case 2:
223	clock = (hid1*50);
224	break;
225	}
226
227	return clock;
228	}
229
230	void __init gemini_init_l2(void)
231	{
232	unsigned char reg, brev, fam, creg;
233	unsigned long cache;
234	unsigned long pvr;
235
236	reg = readb(GEMINI_L2CFG);
237	brev = readb(GEMINI_BREV);
238	fam = readb(GEMINI_FEAT);
239	pvr = mfspr(SPRN_PVR);
240
241	switch(PVR_VER(pvr)) {
242
243	case 8:
244	if (reg & 0xc0)
245	cache = (((reg >> 6) & 0x3) << 28);
246	else
247	cache = 0x3 << 28;
248
249	#ifdef CONFIG_SMP
250	/* Pre-3.0 processor revs had snooping errata. Leave
251	their L2's disabled with SMP. -- Dan */
252	if (PVR_CFG(pvr) < 3) {
253	printk("Pre-3.0 750; L2 left disabled!\n");
254	return;
255	}
256	#endif /* CONFIG_SMP */
257
258	/* Special case: VGM5-B's came before L2 ratios were set on
259	the board. Processor speed shouldn't be too high, so
260	set L2 ratio to 1:1.5. */
261	if ((brev == 0x51) && ((fam & 0xa0) >> 4) == 0)
262	reg \|= 1;
263
264	/* determine best cache ratio based upon what the board
265	tells us (which sometimes _may_ not be true) and
266	the processor speed. */
267	else {
268	if (gemini_get_clock_speed() > 250)
269	reg = 2;
270	}
271	break;
272	case 12:
273	{
274	static unsigned long l2_size_val = 0;
275
276	if (!l2_size_val)
277	l2_size_val = _get_L2CR();
278	cache = l2_size_val;
279	break;
280	}
281	case 4:
282	case 9:
283	creg = readb(GEMINI_CPUSTAT);
284	if (((creg & 0xc) >> 2) != 1)
285	printk("Dual-604 boards don't support the use of L2\n");
286	else
287	writeb(1, GEMINI_L2CFG);
288	return;
289	default:
290	printk("Unknown processor; L2 left disabled\n");
291	return;
292	}
293
294	cache \|= ((1<<reg) << 25);
295	cache \|= (L2CR_L2RAM_MASK\|L2CR_L2CTL\|L2CR_L2DO);
296	_set_L2CR(0);
297	_set_L2CR(cache \| L2CR_L2E);
298
299	}
300
301	void
302	gemini_restart(char *cmd)
303	{
304	local_irq_disable();
305	/* make a clean restart, not via the MPIC */
306	_gemini_reboot();
307	for(;;);
308	}
309
310	void
311	gemini_power_off(void)
312	{
313	for(;;);
314	}
315
316	void
317	gemini_halt(void)
318	{
319	gemini_restart(NULL);
320	}
321
322	void __init gemini_init_IRQ(void)
323	{
324	/* gemini has no 8259 */
325	openpic_init(1, 0, 0, -1);
326	}
327
328	#define gemini_rtc_read(x) (readb(GEMINI_RTC+(x)))
329	#define gemini_rtc_write(val,x) (writeb((val),(GEMINI_RTC+(x))))
330
331	/* ensure that the RTC is up and running */
332	long __init gemini_time_init(void)
333	{
334	unsigned char reg;
335
336	reg = gemini_rtc_read(M48T35_RTC_CONTROL);
337
338	if ( reg & M48T35_RTC_STOPPED ) {
339	printk(KERN_INFO "M48T35 real-time-clock was stopped. Now starting...\n");
340	gemini_rtc_write((reg & ~(M48T35_RTC_STOPPED)), M48T35_RTC_CONTROL);
341	gemini_rtc_write((reg \| M48T35_RTC_SET), M48T35_RTC_CONTROL);
342	}
343	return 0;
344	}
345
346	#undef DEBUG_RTC
347
348	unsigned long
349	gemini_get_rtc_time(void)
350	{
351	unsigned int year, mon, day, hour, min, sec;
352	unsigned char reg;
353
354	reg = gemini_rtc_read(M48T35_RTC_CONTROL);
355	gemini_rtc_write((reg\|M48T35_RTC_READ), M48T35_RTC_CONTROL);
356	#ifdef DEBUG_RTC
357	printk("get rtc: reg = %x\n", reg);
358	#endif
359
360	do {
361	sec = gemini_rtc_read(M48T35_RTC_SECONDS);
362	min = gemini_rtc_read(M48T35_RTC_MINUTES);
363	hour = gemini_rtc_read(M48T35_RTC_HOURS);
364	day = gemini_rtc_read(M48T35_RTC_DOM);
365	mon = gemini_rtc_read(M48T35_RTC_MONTH);
366	year = gemini_rtc_read(M48T35_RTC_YEAR);
367	} while( sec != gemini_rtc_read(M48T35_RTC_SECONDS));
368	#ifdef DEBUG_RTC
369	printk("get rtc: sec=%x, min=%x, hour=%x, day=%x, mon=%x, year=%x\n",
370	sec, min, hour, day, mon, year);
371	#endif
372
373	gemini_rtc_write(reg, M48T35_RTC_CONTROL);
374
375	BCD_TO_BIN(sec);
376	BCD_TO_BIN(min);
377	BCD_TO_BIN(hour);
378	BCD_TO_BIN(day);
379	BCD_TO_BIN(mon);
380	BCD_TO_BIN(year);
381
382	if ((year += 1900) < 1970)
383	year += 100;
384	#ifdef DEBUG_RTC
385	printk("get rtc: sec=%x, min=%x, hour=%x, day=%x, mon=%x, year=%x\n",
386	sec, min, hour, day, mon, year);
387	#endif
388
389	return mktime( year, mon, day, hour, min, sec );
390	}
391
392
393	int
394	gemini_set_rtc_time( unsigned long now )
395	{
396	unsigned char reg;
397	struct rtc_time tm;
398
399	to_tm( now, &tm );
400
401	reg = gemini_rtc_read(M48T35_RTC_CONTROL);
402	#ifdef DEBUG_RTC
403	printk("set rtc: reg = %x\n", reg);
404	#endif
405
406	gemini_rtc_write((reg\|M48T35_RTC_SET), M48T35_RTC_CONTROL);
407	#ifdef DEBUG_RTC
408	printk("set rtc: tm vals - sec=%x, min=%x, hour=%x, mon=%x, mday=%x, year=%x\n",
409	tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mon, tm.tm_mday, tm.tm_year);
410	#endif
411
412	tm.tm_year -= 1900;
413	BIN_TO_BCD(tm.tm_sec);
414	BIN_TO_BCD(tm.tm_min);
415	BIN_TO_BCD(tm.tm_hour);
416	BIN_TO_BCD(tm.tm_mon);
417	BIN_TO_BCD(tm.tm_mday);
418	BIN_TO_BCD(tm.tm_year);
419	#ifdef DEBUG_RTC
420	printk("set rtc: tm vals - sec=%x, min=%x, hour=%x, mon=%x, mday=%x, year=%x\n",
421	tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mon, tm.tm_mday, tm.tm_year);
422	#endif
423
424	gemini_rtc_write(tm.tm_sec, M48T35_RTC_SECONDS);
425	gemini_rtc_write(tm.tm_min, M48T35_RTC_MINUTES);
426	gemini_rtc_write(tm.tm_hour, M48T35_RTC_HOURS);
427	gemini_rtc_write(tm.tm_mday, M48T35_RTC_DOM);
428	gemini_rtc_write(tm.tm_mon, M48T35_RTC_MONTH);
429	gemini_rtc_write(tm.tm_year, M48T35_RTC_YEAR);
430
431	/* done writing */
432	gemini_rtc_write(reg, M48T35_RTC_CONTROL);
433
1da177e4 LT	434	return 0;
	435	}
	436
	437	/* use the RTC to determine the decrementer count */
	438	void __init gemini_calibrate_decr(void)
	439	{
	440	int freq, divisor;
	441	unsigned char reg;
	442
	443	/* determine processor bus speed */
	444	reg = readb(GEMINI_BSTAT);
	445
	446	switch(((reg & 0x0c)>>2)&0x3) {
	447	case 0:
	448	default:
	449	freq = 66667;
	450	break;
	451	case 1:
	452	freq = 83000;
	453	break;
	454	case 2:
	455	freq = 100000;
	456	break;
	457	}
	458
	459	freq *= 1000;
	460	divisor = 4;
	461	tb_ticks_per_jiffy = freq / HZ / divisor;
	462	tb_to_us = mulhwu_scale_factor(freq/divisor, 1000000);
	463	}
	464
	465	unsigned long __init gemini_find_end_of_memory(void)
	466	{
	467	unsigned long total;
	468	unsigned char reg;
	469
	470	reg = readb(GEMINI_MEMCFG);
	471	total = ((1<<((reg & 0x7) - 1)) *
	472	(8<<((reg >> 3) & 0x7)));
	473	total = (10241024);
	474	return total;
	475	}
	476
	477	static void __init
	478	gemini_map_io(void)
	479	{
	480	io_block_mapping(0xf0000000, 0xf0000000, 0x10000000, _PAGE_IO);
	481	io_block_mapping(0x80000000, 0x80000000, 0x10000000, _PAGE_IO);
	482	}
	483
	484	#ifdef CONFIG_SMP
	485	static int
	486	smp_gemini_probe(void)
	487	{
	488	int i, nr;
	489
	490	nr = (readb(GEMINI_CPUSTAT) & GEMINI_CPU_COUNT_MASK) >> 2;
	491	if (nr == 0)
	492	nr = 4;
	493
	494	if (nr > 1) {
	495	openpic_request_IPIs();
	496	for (i = 1; i < nr; ++i)
	497	smp_hw_index[i] = i;
498	}
499
500	return nr;
501	}
502
503	static void
504	smp_gemini_kick_cpu(int nr)
505	{
506	openpic_reset_processor_phys(1 << nr);
507	openpic_reset_processor_phys(0);
508	}
509
510	static void
511	smp_gemini_setup_cpu(int cpu_nr)
512	{
513	if (OpenPIC_Addr)
514	do_openpic_setup_cpu();
515	if (cpu_nr > 0)
516	gemini_init_l2();
517	}
518
519	static struct smp_ops_t gemini_smp_ops = {
520	smp_openpic_message_pass,
521	smp_gemini_probe,
522	smp_gemini_kick_cpu,
523	smp_gemini_setup_cpu,
524	.give_timebase = smp_generic_give_timebase,
525	.take_timebase = smp_generic_take_timebase,
526	};
527	#endif /* CONFIG_SMP */
528
529	void __init platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
530	unsigned long r6, unsigned long r7)
531	{
532	int i;
533
534	/* Restore BATs for now */
535	mtspr(SPRN_DBAT3U, 0xf0001fff);
536	mtspr(SPRN_DBAT3L, 0xf000002a);
537
538	parse_bootinfo(find_bootinfo());
539
540	for(i = 0; i < GEMINI_LEDS; i++)
541	gemini_led_off(i);
542
543	ISA_DMA_THRESHOLD = 0;
544	DMA_MODE_READ = 0;
545	DMA_MODE_WRITE = 0;
546
547	#ifdef CONFIG_BLK_DEV_INITRD
548	if ( r4 )
549	{
550	initrd_start = r4 + KERNELBASE;
551	initrd_end = r5 + KERNELBASE;
552	}
553	#endif
554
555	ppc_md.setup_arch = gemini_setup_arch;
556	ppc_md.show_cpuinfo = gemini_show_cpuinfo;
1da177e4 LT	557	ppc_md.init_IRQ = gemini_init_IRQ;
	558	ppc_md.get_irq = openpic_get_irq;
	559	ppc_md.init = NULL;
	560
	561	ppc_md.restart = gemini_restart;
	562	ppc_md.power_off = gemini_power_off;
	563	ppc_md.halt = gemini_halt;
	564
	565	ppc_md.time_init = gemini_time_init;
	566	ppc_md.set_rtc_time = gemini_set_rtc_time;
	567	ppc_md.get_rtc_time = gemini_get_rtc_time;
	568	ppc_md.calibrate_decr = gemini_calibrate_decr;
	569
	570	ppc_md.find_end_of_memory = gemini_find_end_of_memory;
	571	ppc_md.setup_io_mappings = gemini_map_io;
	572
	573	ppc_md.pcibios_fixup_bus = gemini_pcibios_fixup;
	574
	575	#ifdef CONFIG_SMP
7ed476d1	576	smp_ops = &gemini_smp_ops;
1da177e4 LT	577	#endif /* CONFIG_SMP */
1da177e4 LT	578	}