Eric Lee / linux-smarc-t335x-v3.2

Commit c8f1c8be629ee34991fdba8bfe46a5c455393209

Authored by Milton Miller 2005-09-06 09:56:42 +0800

Committed by Paul Mackerras 2005-09-06 14:07:36 +0800

Exists in master and in 4 other branches

[PATCH] ppc64: Take udbg out of ppc_md

Take udbg out of ppc_md. Allows us to not overwrite early udbg inits
when assigning ppc_md.

Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: Anton Blanchard <anton@samba.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>

Showing 9 changed files with 51 additions and 58 deletions Inline Diff

arch/ppc64/kernel/pSeries_lpar.c
arch/ppc64/kernel/pmac_setup.c
arch/ppc64/kernel/setup.c
arch/ppc64/kernel/udbg.c
arch/ppc64/kernel/udbg_16550.c
arch/ppc64/kernel/udbg_scc.c
arch/ppc64/xmon/start.c
include/asm-ppc64/machdep.h
include/asm-ppc64/udbg.h

arch/ppc64/kernel/pSeries_lpar.c

Diff comments View file @ c8f1c8b

1	/*	1	/*
2	* pSeries_lpar.c	2	* pSeries_lpar.c
3	* Copyright (C) 2001 Todd Inglett, IBM Corporation	3	* Copyright (C) 2001 Todd Inglett, IBM Corporation
4	*	4	*
5	* pSeries LPAR support.	5	* pSeries LPAR support.
6	*	6	*
7	* This program is free software; you can redistribute it and/or modify	7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by	8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or	9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.	10	* (at your option) any later version.
11	*	11	*
12	* This program is distributed in the hope that it will be useful,	12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.	15	* GNU General Public License for more details.
16	*	16	*
17	* You should have received a copy of the GNU General Public License	17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software	18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	*/	20	*/
21		21
22	#define DEBUG	22	#define DEBUG
23		23
24	#include <linux/config.h>	24	#include <linux/config.h>
25	#include <linux/kernel.h>	25	#include <linux/kernel.h>
26	#include <linux/dma-mapping.h>	26	#include <linux/dma-mapping.h>
27	#include <asm/processor.h>	27	#include <asm/processor.h>
28	#include <asm/mmu.h>	28	#include <asm/mmu.h>
29	#include <asm/page.h>	29	#include <asm/page.h>
30	#include <asm/pgtable.h>	30	#include <asm/pgtable.h>
31	#include <asm/machdep.h>	31	#include <asm/machdep.h>
32	#include <asm/abs_addr.h>	32	#include <asm/abs_addr.h>
33	#include <asm/mmu_context.h>	33	#include <asm/mmu_context.h>
34	#include <asm/ppcdebug.h>	34	#include <asm/ppcdebug.h>
35	#include <asm/iommu.h>	35	#include <asm/iommu.h>
36	#include <asm/tlbflush.h>	36	#include <asm/tlbflush.h>
37	#include <asm/tlb.h>	37	#include <asm/tlb.h>
38	#include <asm/prom.h>	38	#include <asm/prom.h>
39	#include <asm/abs_addr.h>	39	#include <asm/abs_addr.h>
40	#include <asm/cputable.h>	40	#include <asm/cputable.h>
41	#include <asm/plpar_wrappers.h>	41	#include <asm/plpar_wrappers.h>
42		42
43	#ifdef DEBUG	43	#ifdef DEBUG
44	#define DBG(fmt...) udbg_printf(fmt)	44	#define DBG(fmt...) udbg_printf(fmt)
45	#else	45	#else
46	#define DBG(fmt...)	46	#define DBG(fmt...)
47	#endif	47	#endif
48		48
49	/* in pSeries_hvCall.S */	49	/* in pSeries_hvCall.S */
50	EXPORT_SYMBOL(plpar_hcall);	50	EXPORT_SYMBOL(plpar_hcall);
51	EXPORT_SYMBOL(plpar_hcall_4out);	51	EXPORT_SYMBOL(plpar_hcall_4out);
52	EXPORT_SYMBOL(plpar_hcall_norets);	52	EXPORT_SYMBOL(plpar_hcall_norets);
53	EXPORT_SYMBOL(plpar_hcall_8arg_2ret);	53	EXPORT_SYMBOL(plpar_hcall_8arg_2ret);
54		54
55	extern void pSeries_find_serial_port(void);	55	extern void pSeries_find_serial_port(void);
56		56
57		57
58	int vtermno; /* virtual terminal# for udbg */	58	int vtermno; /* virtual terminal# for udbg */
59		59
60	#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))	60	#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
61	static void udbg_hvsi_putc(unsigned char c)	61	static void udbg_hvsi_putc(unsigned char c)
62	{	62	{
63	/* packet's seqno isn't used anyways */	63	/* packet's seqno isn't used anyways */
64	uint8_t packet[] __ALIGNED__ = { 0xff, 5, 0, 0, c };	64	uint8_t packet[] __ALIGNED__ = { 0xff, 5, 0, 0, c };
65	int rc;	65	int rc;
66		66
67	if (c == '\n')	67	if (c == '\n')
68	udbg_hvsi_putc('\r');	68	udbg_hvsi_putc('\r');
69		69
70	do {	70	do {
71	rc = plpar_put_term_char(vtermno, sizeof(packet), packet);	71	rc = plpar_put_term_char(vtermno, sizeof(packet), packet);
72	} while (rc == H_Busy);	72	} while (rc == H_Busy);
73	}	73	}
74		74
75	static long hvsi_udbg_buf_len;	75	static long hvsi_udbg_buf_len;
76	static uint8_t hvsi_udbg_buf[256];	76	static uint8_t hvsi_udbg_buf[256];
77		77
78	static int udbg_hvsi_getc_poll(void)	78	static int udbg_hvsi_getc_poll(void)
79	{	79	{
80	unsigned char ch;	80	unsigned char ch;
81	int rc, i;	81	int rc, i;
82		82
83	if (hvsi_udbg_buf_len == 0) {	83	if (hvsi_udbg_buf_len == 0) {
84	rc = plpar_get_term_char(vtermno, &hvsi_udbg_buf_len, hvsi_udbg_buf);	84	rc = plpar_get_term_char(vtermno, &hvsi_udbg_buf_len, hvsi_udbg_buf);
85	if (rc != H_Success \|\| hvsi_udbg_buf[0] != 0xff) {	85	if (rc != H_Success \|\| hvsi_udbg_buf[0] != 0xff) {
86	/* bad read or non-data packet */	86	/* bad read or non-data packet */
87	hvsi_udbg_buf_len = 0;	87	hvsi_udbg_buf_len = 0;
88	} else {	88	} else {
89	/* remove the packet header */	89	/* remove the packet header */
90	for (i = 4; i < hvsi_udbg_buf_len; i++)	90	for (i = 4; i < hvsi_udbg_buf_len; i++)
91	hvsi_udbg_buf[i-4] = hvsi_udbg_buf[i];	91	hvsi_udbg_buf[i-4] = hvsi_udbg_buf[i];
92	hvsi_udbg_buf_len -= 4;	92	hvsi_udbg_buf_len -= 4;
93	}	93	}
94	}	94	}
95		95
96	if (hvsi_udbg_buf_len <= 0 \|\| hvsi_udbg_buf_len > 256) {	96	if (hvsi_udbg_buf_len <= 0 \|\| hvsi_udbg_buf_len > 256) {
97	/* no data ready */	97	/* no data ready */
98	hvsi_udbg_buf_len = 0;	98	hvsi_udbg_buf_len = 0;
99	return -1;	99	return -1;
100	}	100	}
101		101
102	ch = hvsi_udbg_buf[0];	102	ch = hvsi_udbg_buf[0];
103	/* shift remaining data down */	103	/* shift remaining data down */
104	for (i = 1; i < hvsi_udbg_buf_len; i++) {	104	for (i = 1; i < hvsi_udbg_buf_len; i++) {
105	hvsi_udbg_buf[i-1] = hvsi_udbg_buf[i];	105	hvsi_udbg_buf[i-1] = hvsi_udbg_buf[i];
106	}	106	}
107	hvsi_udbg_buf_len--;	107	hvsi_udbg_buf_len--;
108		108
109	return ch;	109	return ch;
110	}	110	}
111		111
112	static unsigned char udbg_hvsi_getc(void)	112	static unsigned char udbg_hvsi_getc(void)
113	{	113	{
114	int ch;	114	int ch;
115	for (;;) {	115	for (;;) {
116	ch = udbg_hvsi_getc_poll();	116	ch = udbg_hvsi_getc_poll();
117	if (ch == -1) {	117	if (ch == -1) {
118	/* This shouldn't be needed...but... */	118	/* This shouldn't be needed...but... */
119	volatile unsigned long delay;	119	volatile unsigned long delay;
120	for (delay=0; delay < 2000000; delay++)	120	for (delay=0; delay < 2000000; delay++)
121	;	121	;
122	} else {	122	} else {
123	return ch;	123	return ch;
124	}	124	}
125	}	125	}
126	}	126	}
127		127
128	static void udbg_putcLP(unsigned char c)	128	static void udbg_putcLP(unsigned char c)
129	{	129	{
130	char buf[16];	130	char buf[16];
131	unsigned long rc;	131	unsigned long rc;
132		132
133	if (c == '\n')	133	if (c == '\n')
134	udbg_putcLP('\r');	134	udbg_putcLP('\r');
135		135
136	buf[0] = c;	136	buf[0] = c;
137	do {	137	do {
138	rc = plpar_put_term_char(vtermno, 1, buf);	138	rc = plpar_put_term_char(vtermno, 1, buf);
139	} while(rc == H_Busy);	139	} while(rc == H_Busy);
140	}	140	}
141		141
142	/* Buffered chars getc */	142	/* Buffered chars getc */
143	static long inbuflen;	143	static long inbuflen;
144	static long inbuf[2]; /* must be 2 longs */	144	static long inbuf[2]; /* must be 2 longs */
145		145
146	static int udbg_getc_pollLP(void)	146	static int udbg_getc_pollLP(void)
147	{	147	{
148	/* The interface is tricky because it may return up to 16 chars.	148	/* The interface is tricky because it may return up to 16 chars.
149	* We save them statically for future calls to udbg_getc().	149	* We save them statically for future calls to udbg_getc().
150	*/	150	*/
151	char ch, buf = (char )inbuf;	151	char ch, buf = (char )inbuf;
152	int i;	152	int i;
153	long rc;	153	long rc;
154	if (inbuflen == 0) {	154	if (inbuflen == 0) {
155	/* get some more chars. */	155	/* get some more chars. */
156	inbuflen = 0;	156	inbuflen = 0;
157	rc = plpar_get_term_char(vtermno, &inbuflen, buf);	157	rc = plpar_get_term_char(vtermno, &inbuflen, buf);
158	if (rc != H_Success)	158	if (rc != H_Success)
159	inbuflen = 0; /* otherwise inbuflen is garbage */	159	inbuflen = 0; /* otherwise inbuflen is garbage */
160	}	160	}
161	if (inbuflen <= 0 \|\| inbuflen > 16) {	161	if (inbuflen <= 0 \|\| inbuflen > 16) {
162	/* Catch error case as well as other oddities (corruption) */	162	/* Catch error case as well as other oddities (corruption) */
163	inbuflen = 0;	163	inbuflen = 0;
164	return -1;	164	return -1;
165	}	165	}
166	ch = buf[0];	166	ch = buf[0];
167	for (i = 1; i < inbuflen; i++) /* shuffle them down. */	167	for (i = 1; i < inbuflen; i++) /* shuffle them down. */
168	buf[i-1] = buf[i];	168	buf[i-1] = buf[i];
169	inbuflen--;	169	inbuflen--;
170	return ch;	170	return ch;
171	}	171	}
172		172
173	static unsigned char udbg_getcLP(void)	173	static unsigned char udbg_getcLP(void)
174	{	174	{
175	int ch;	175	int ch;
176	for (;;) {	176	for (;;) {
177	ch = udbg_getc_pollLP();	177	ch = udbg_getc_pollLP();
178	if (ch == -1) {	178	if (ch == -1) {
179	/* This shouldn't be needed...but... */	179	/* This shouldn't be needed...but... */
180	volatile unsigned long delay;	180	volatile unsigned long delay;
181	for (delay=0; delay < 2000000; delay++)	181	for (delay=0; delay < 2000000; delay++)
182	;	182	;
183	} else {	183	} else {
184	return ch;	184	return ch;
185	}	185	}
186	}	186	}
187	}	187	}
188		188
189	/* call this from early_init() for a working debug console on	189	/* call this from early_init() for a working debug console on
190	* vterm capable LPAR machines	190	* vterm capable LPAR machines
191	*/	191	*/
192	void udbg_init_debug_lpar(void)	192	void udbg_init_debug_lpar(void)
193	{	193	{
194	vtermno = 0;	194	vtermno = 0;
195	ppc_md.udbg_putc = udbg_putcLP;	195	udbg_putc = udbg_putcLP;
196	ppc_md.udbg_getc = udbg_getcLP;	196	udbg_getc = udbg_getcLP;
197	ppc_md.udbg_getc_poll = udbg_getc_pollLP;	197	udbg_getc_poll = udbg_getc_pollLP;
198	}	198	}
199		199
200	/* returns 0 if couldn't find or use /chosen/stdout as console */	200	/* returns 0 if couldn't find or use /chosen/stdout as console */
201	int find_udbg_vterm(void)	201	int find_udbg_vterm(void)
202	{	202	{
203	struct device_node *stdout_node;	203	struct device_node *stdout_node;
204	u32 *termno;	204	u32 *termno;
205	char *name;	205	char *name;
206	int found = 0;	206	int found = 0;
207		207
208	/* find the boot console from /chosen/stdout */	208	/* find the boot console from /chosen/stdout */
209	if (!of_chosen)	209	if (!of_chosen)
210	return 0;	210	return 0;
211	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);	211	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
212	if (name == NULL)	212	if (name == NULL)
213	return 0;	213	return 0;
214	stdout_node = of_find_node_by_path(name);	214	stdout_node = of_find_node_by_path(name);
215	if (!stdout_node)	215	if (!stdout_node)
216	return 0;	216	return 0;
217		217
218	/* now we have the stdout node; figure out what type of device it is. */	218	/* now we have the stdout node; figure out what type of device it is. */
219	name = (char *)get_property(stdout_node, "name", NULL);	219	name = (char *)get_property(stdout_node, "name", NULL);
220	if (!name) {	220	if (!name) {
221	printk(KERN_WARNING "stdout node missing 'name' property!\n");	221	printk(KERN_WARNING "stdout node missing 'name' property!\n");
222	goto out;	222	goto out;
223	}	223	}
224		224
225	if (strncmp(name, "vty", 3) == 0) {	225	if (strncmp(name, "vty", 3) == 0) {
226	if (device_is_compatible(stdout_node, "hvterm1")) {	226	if (device_is_compatible(stdout_node, "hvterm1")) {
227	termno = (u32 *)get_property(stdout_node, "reg", NULL);	227	termno = (u32 *)get_property(stdout_node, "reg", NULL);
228	if (termno) {	228	if (termno) {
229	vtermno = termno[0];	229	vtermno = termno[0];
230	ppc_md.udbg_putc = udbg_putcLP;	230	udbg_putc = udbg_putcLP;
231	ppc_md.udbg_getc = udbg_getcLP;	231	udbg_getc = udbg_getcLP;
232	ppc_md.udbg_getc_poll = udbg_getc_pollLP;	232	udbg_getc_poll = udbg_getc_pollLP;
233	found = 1;	233	found = 1;
234	}	234	}
235	} else if (device_is_compatible(stdout_node, "hvterm-protocol")) {	235	} else if (device_is_compatible(stdout_node, "hvterm-protocol")) {
236	termno = (u32 *)get_property(stdout_node, "reg", NULL);	236	termno = (u32 *)get_property(stdout_node, "reg", NULL);
237	if (termno) {	237	if (termno) {
238	vtermno = termno[0];	238	vtermno = termno[0];
239	ppc_md.udbg_putc = udbg_hvsi_putc;	239	udbg_putc = udbg_hvsi_putc;
240	ppc_md.udbg_getc = udbg_hvsi_getc;	240	udbg_getc = udbg_hvsi_getc;
241	ppc_md.udbg_getc_poll = udbg_hvsi_getc_poll;	241	udbg_getc_poll = udbg_hvsi_getc_poll;
242	found = 1;	242	found = 1;
243	}	243	}
244	}	244	}
245	} else if (strncmp(name, "serial", 6)) {	245	} else if (strncmp(name, "serial", 6)) {
246	/* XXX fix ISA serial console */	246	/* XXX fix ISA serial console */
247	printk(KERN_WARNING "serial stdout on LPAR ('%s')! "	247	printk(KERN_WARNING "serial stdout on LPAR ('%s')! "
248	"can't print udbg messages\n",	248	"can't print udbg messages\n",
249	stdout_node->full_name);	249	stdout_node->full_name);
250	} else {	250	} else {
251	printk(KERN_WARNING "don't know how to print to stdout '%s'\n",	251	printk(KERN_WARNING "don't know how to print to stdout '%s'\n",
252	stdout_node->full_name);	252	stdout_node->full_name);
253	}	253	}
254		254
255	out:	255	out:
256	of_node_put(stdout_node);	256	of_node_put(stdout_node);
257	return found;	257	return found;
258	}	258	}
259		259
260	void vpa_init(int cpu)	260	void vpa_init(int cpu)
261	{	261	{
262	int hwcpu = get_hard_smp_processor_id(cpu);	262	int hwcpu = get_hard_smp_processor_id(cpu);
263	unsigned long vpa = (unsigned long)&(paca[cpu].lppaca);	263	unsigned long vpa = (unsigned long)&(paca[cpu].lppaca);
264	long ret;	264	long ret;
265	unsigned long flags;	265	unsigned long flags;
266		266
267	/* Register the Virtual Processor Area (VPA) */	267	/* Register the Virtual Processor Area (VPA) */
268	flags = 1UL << (63 - 18);	268	flags = 1UL << (63 - 18);
269		269
270	if (cpu_has_feature(CPU_FTR_ALTIVEC))	270	if (cpu_has_feature(CPU_FTR_ALTIVEC))
271	paca[cpu].lppaca.vmxregs_in_use = 1;	271	paca[cpu].lppaca.vmxregs_in_use = 1;
272		272
273	ret = register_vpa(flags, hwcpu, __pa(vpa));	273	ret = register_vpa(flags, hwcpu, __pa(vpa));
274		274
275	if (ret)	275	if (ret)
276	printk(KERN_ERR "WARNING: vpa_init: VPA registration for "	276	printk(KERN_ERR "WARNING: vpa_init: VPA registration for "
277	"cpu %d (hw %d) of area %lx returns %ld\n",	277	"cpu %d (hw %d) of area %lx returns %ld\n",
278	cpu, hwcpu, __pa(vpa), ret);	278	cpu, hwcpu, __pa(vpa), ret);
279	}	279	}
280		280
281	long pSeries_lpar_hpte_insert(unsigned long hpte_group,	281	long pSeries_lpar_hpte_insert(unsigned long hpte_group,
282	unsigned long va, unsigned long prpn,	282	unsigned long va, unsigned long prpn,
283	unsigned long vflags, unsigned long rflags)	283	unsigned long vflags, unsigned long rflags)
284	{	284	{
285	unsigned long lpar_rc;	285	unsigned long lpar_rc;
286	unsigned long flags;	286	unsigned long flags;
287	unsigned long slot;	287	unsigned long slot;
288	unsigned long hpte_v, hpte_r;	288	unsigned long hpte_v, hpte_r;
289	unsigned long dummy0, dummy1;	289	unsigned long dummy0, dummy1;
290		290
291	hpte_v = ((va >> 23) << HPTE_V_AVPN_SHIFT) \| vflags \| HPTE_V_VALID;	291	hpte_v = ((va >> 23) << HPTE_V_AVPN_SHIFT) \| vflags \| HPTE_V_VALID;
292	if (vflags & HPTE_V_LARGE)	292	if (vflags & HPTE_V_LARGE)
293	hpte_v &= ~(1UL << HPTE_V_AVPN_SHIFT);	293	hpte_v &= ~(1UL << HPTE_V_AVPN_SHIFT);
294		294
295	hpte_r = (prpn << HPTE_R_RPN_SHIFT) \| rflags;	295	hpte_r = (prpn << HPTE_R_RPN_SHIFT) \| rflags;
296		296
297	/* Now fill in the actual HPTE */	297	/* Now fill in the actual HPTE */
298	/* Set CEC cookie to 0 */	298	/* Set CEC cookie to 0 */
299	/* Zero page = 0 */	299	/* Zero page = 0 */
300	/* I-cache Invalidate = 0 */	300	/* I-cache Invalidate = 0 */
301	/* I-cache synchronize = 0 */	301	/* I-cache synchronize = 0 */
302	/* Exact = 0 */	302	/* Exact = 0 */
303	flags = 0;	303	flags = 0;
304		304
305	/* XXX why is this here? - Anton */	305	/* XXX why is this here? - Anton */
306	if (rflags & (_PAGE_GUARDED\|_PAGE_NO_CACHE))	306	if (rflags & (_PAGE_GUARDED\|_PAGE_NO_CACHE))
307	hpte_r &= ~_PAGE_COHERENT;	307	hpte_r &= ~_PAGE_COHERENT;
308		308
309	lpar_rc = plpar_hcall(H_ENTER, flags, hpte_group, hpte_v,	309	lpar_rc = plpar_hcall(H_ENTER, flags, hpte_group, hpte_v,
310	hpte_r, &slot, &dummy0, &dummy1);	310	hpte_r, &slot, &dummy0, &dummy1);
311		311
312	if (unlikely(lpar_rc == H_PTEG_Full))	312	if (unlikely(lpar_rc == H_PTEG_Full))
313	return -1;	313	return -1;
314		314
315	/*	315	/*
316	* Since we try and ioremap PHBs we don't own, the pte insert	316	* Since we try and ioremap PHBs we don't own, the pte insert
317	* will fail. However we must catch the failure in hash_page	317	* will fail. However we must catch the failure in hash_page
318	* or we will loop forever, so return -2 in this case.	318	* or we will loop forever, so return -2 in this case.
319	*/	319	*/
320	if (unlikely(lpar_rc != H_Success))	320	if (unlikely(lpar_rc != H_Success))
321	return -2;	321	return -2;
322		322
323	/* Because of iSeries, we have to pass down the secondary	323	/* Because of iSeries, we have to pass down the secondary
324	* bucket bit here as well	324	* bucket bit here as well
325	*/	325	*/
326	return (slot & 7) \| (!!(vflags & HPTE_V_SECONDARY) << 3);	326	return (slot & 7) \| (!!(vflags & HPTE_V_SECONDARY) << 3);
327	}	327	}
328		328
329	static DEFINE_SPINLOCK(pSeries_lpar_tlbie_lock);	329	static DEFINE_SPINLOCK(pSeries_lpar_tlbie_lock);
330		330
331	static long pSeries_lpar_hpte_remove(unsigned long hpte_group)	331	static long pSeries_lpar_hpte_remove(unsigned long hpte_group)
332	{	332	{
333	unsigned long slot_offset;	333	unsigned long slot_offset;
334	unsigned long lpar_rc;	334	unsigned long lpar_rc;
335	int i;	335	int i;
336	unsigned long dummy1, dummy2;	336	unsigned long dummy1, dummy2;
337		337
338	/* pick a random slot to start at */	338	/* pick a random slot to start at */
339	slot_offset = mftb() & 0x7;	339	slot_offset = mftb() & 0x7;
340		340
341	for (i = 0; i < HPTES_PER_GROUP; i++) {	341	for (i = 0; i < HPTES_PER_GROUP; i++) {
342		342
343	/* don't remove a bolted entry */	343	/* don't remove a bolted entry */
344	lpar_rc = plpar_pte_remove(H_ANDCOND, hpte_group + slot_offset,	344	lpar_rc = plpar_pte_remove(H_ANDCOND, hpte_group + slot_offset,
345	(0x1UL << 4), &dummy1, &dummy2);	345	(0x1UL << 4), &dummy1, &dummy2);
346		346
347	if (lpar_rc == H_Success)	347	if (lpar_rc == H_Success)
348	return i;	348	return i;
349		349
350	BUG_ON(lpar_rc != H_Not_Found);	350	BUG_ON(lpar_rc != H_Not_Found);
351		351
352	slot_offset++;	352	slot_offset++;
353	slot_offset &= 0x7;	353	slot_offset &= 0x7;
354	}	354	}
355		355
356	return -1;	356	return -1;
357	}	357	}
358		358
359	static void pSeries_lpar_hptab_clear(void)	359	static void pSeries_lpar_hptab_clear(void)
360	{	360	{
361	unsigned long size_bytes = 1UL << ppc64_pft_size;	361	unsigned long size_bytes = 1UL << ppc64_pft_size;
362	unsigned long hpte_count = size_bytes >> 4;	362	unsigned long hpte_count = size_bytes >> 4;
363	unsigned long dummy1, dummy2;	363	unsigned long dummy1, dummy2;
364	int i;	364	int i;
365		365
366	/* TODO: Use bulk call */	366	/* TODO: Use bulk call */
367	for (i = 0; i < hpte_count; i++)	367	for (i = 0; i < hpte_count; i++)
368	plpar_pte_remove(0, i, 0, &dummy1, &dummy2);	368	plpar_pte_remove(0, i, 0, &dummy1, &dummy2);
369	}	369	}
370		370
371	/*	371	/*
372	* NOTE: for updatepp ops we are fortunate that the linux "newpp" bits and	372	* NOTE: for updatepp ops we are fortunate that the linux "newpp" bits and
373	* the low 3 bits of flags happen to line up. So no transform is needed.	373	* the low 3 bits of flags happen to line up. So no transform is needed.
374	* We can probably optimize here and assume the high bits of newpp are	374	* We can probably optimize here and assume the high bits of newpp are
375	* already zero. For now I am paranoid.	375	* already zero. For now I am paranoid.
376	*/	376	*/
377	static long pSeries_lpar_hpte_updatepp(unsigned long slot, unsigned long newpp,	377	static long pSeries_lpar_hpte_updatepp(unsigned long slot, unsigned long newpp,
378	unsigned long va, int large, int local)	378	unsigned long va, int large, int local)
379	{	379	{
380	unsigned long lpar_rc;	380	unsigned long lpar_rc;
381	unsigned long flags = (newpp & 7) \| H_AVPN;	381	unsigned long flags = (newpp & 7) \| H_AVPN;
382	unsigned long avpn = va >> 23;	382	unsigned long avpn = va >> 23;
383		383
384	if (large)	384	if (large)
385	avpn &= ~0x1UL;	385	avpn &= ~0x1UL;
386		386
387	lpar_rc = plpar_pte_protect(flags, slot, (avpn << 7));	387	lpar_rc = plpar_pte_protect(flags, slot, (avpn << 7));
388		388
389	if (lpar_rc == H_Not_Found)	389	if (lpar_rc == H_Not_Found)
390	return -1;	390	return -1;
391		391
392	BUG_ON(lpar_rc != H_Success);	392	BUG_ON(lpar_rc != H_Success);
393		393
394	return 0;	394	return 0;
395	}	395	}
396		396
397	static unsigned long pSeries_lpar_hpte_getword0(unsigned long slot)	397	static unsigned long pSeries_lpar_hpte_getword0(unsigned long slot)
398	{	398	{
399	unsigned long dword0;	399	unsigned long dword0;
400	unsigned long lpar_rc;	400	unsigned long lpar_rc;
401	unsigned long dummy_word1;	401	unsigned long dummy_word1;
402	unsigned long flags;	402	unsigned long flags;
403		403
404	/* Read 1 pte at a time */	404	/* Read 1 pte at a time */
405	/* Do not need RPN to logical page translation */	405	/* Do not need RPN to logical page translation */
406	/* No cross CEC PFT access */	406	/* No cross CEC PFT access */
407	flags = 0;	407	flags = 0;
408		408
409	lpar_rc = plpar_pte_read(flags, slot, &dword0, &dummy_word1);	409	lpar_rc = plpar_pte_read(flags, slot, &dword0, &dummy_word1);
410		410
411	BUG_ON(lpar_rc != H_Success);	411	BUG_ON(lpar_rc != H_Success);
412		412
413	return dword0;	413	return dword0;
414	}	414	}
415		415
416	static long pSeries_lpar_hpte_find(unsigned long vpn)	416	static long pSeries_lpar_hpte_find(unsigned long vpn)
417	{	417	{
418	unsigned long hash;	418	unsigned long hash;
419	unsigned long i, j;	419	unsigned long i, j;
420	long slot;	420	long slot;
421	unsigned long hpte_v;	421	unsigned long hpte_v;
422		422
423	hash = hpt_hash(vpn, 0);	423	hash = hpt_hash(vpn, 0);
424		424
425	for (j = 0; j < 2; j++) {	425	for (j = 0; j < 2; j++) {
426	slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;	426	slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
427	for (i = 0; i < HPTES_PER_GROUP; i++) {	427	for (i = 0; i < HPTES_PER_GROUP; i++) {
428	hpte_v = pSeries_lpar_hpte_getword0(slot);	428	hpte_v = pSeries_lpar_hpte_getword0(slot);
429		429
430	if ((HPTE_V_AVPN_VAL(hpte_v) == (vpn >> 11))	430	if ((HPTE_V_AVPN_VAL(hpte_v) == (vpn >> 11))
431	&& (hpte_v & HPTE_V_VALID)	431	&& (hpte_v & HPTE_V_VALID)
432	&& (!!(hpte_v & HPTE_V_SECONDARY) == j)) {	432	&& (!!(hpte_v & HPTE_V_SECONDARY) == j)) {
433	/* HPTE matches */	433	/* HPTE matches */
434	if (j)	434	if (j)
435	slot = -slot;	435	slot = -slot;
436	return slot;	436	return slot;
437	}	437	}
438	++slot;	438	++slot;
439	}	439	}
440	hash = ~hash;	440	hash = ~hash;
441	}	441	}
442		442
443	return -1;	443	return -1;
444	}	444	}
445		445
446	static void pSeries_lpar_hpte_updateboltedpp(unsigned long newpp,	446	static void pSeries_lpar_hpte_updateboltedpp(unsigned long newpp,
447	unsigned long ea)	447	unsigned long ea)
448	{	448	{
449	unsigned long lpar_rc;	449	unsigned long lpar_rc;
450	unsigned long vsid, va, vpn, flags;	450	unsigned long vsid, va, vpn, flags;
451	long slot;	451	long slot;
452		452
453	vsid = get_kernel_vsid(ea);	453	vsid = get_kernel_vsid(ea);
454	va = (vsid << 28) \| (ea & 0x0fffffff);	454	va = (vsid << 28) \| (ea & 0x0fffffff);
455	vpn = va >> PAGE_SHIFT;	455	vpn = va >> PAGE_SHIFT;
456		456
457	slot = pSeries_lpar_hpte_find(vpn);	457	slot = pSeries_lpar_hpte_find(vpn);
458	BUG_ON(slot == -1);	458	BUG_ON(slot == -1);
459		459
460	flags = newpp & 7;	460	flags = newpp & 7;
461	lpar_rc = plpar_pte_protect(flags, slot, 0);	461	lpar_rc = plpar_pte_protect(flags, slot, 0);
462		462
463	BUG_ON(lpar_rc != H_Success);	463	BUG_ON(lpar_rc != H_Success);
464	}	464	}
465		465
466	static void pSeries_lpar_hpte_invalidate(unsigned long slot, unsigned long va,	466	static void pSeries_lpar_hpte_invalidate(unsigned long slot, unsigned long va,
467	int large, int local)	467	int large, int local)
468	{	468	{
469	unsigned long avpn = va >> 23;	469	unsigned long avpn = va >> 23;
470	unsigned long lpar_rc;	470	unsigned long lpar_rc;
471	unsigned long dummy1, dummy2;	471	unsigned long dummy1, dummy2;
472		472
473	if (large)	473	if (large)
474	avpn &= ~0x1UL;	474	avpn &= ~0x1UL;
475		475
476	lpar_rc = plpar_pte_remove(H_AVPN, slot, (avpn << 7), &dummy1,	476	lpar_rc = plpar_pte_remove(H_AVPN, slot, (avpn << 7), &dummy1,
477	&dummy2);	477	&dummy2);
478		478
479	if (lpar_rc == H_Not_Found)	479	if (lpar_rc == H_Not_Found)
480	return;	480	return;
481		481
482	BUG_ON(lpar_rc != H_Success);	482	BUG_ON(lpar_rc != H_Success);
483	}	483	}
484		484
485	/*	485	/*
486	* Take a spinlock around flushes to avoid bouncing the hypervisor tlbie	486	* Take a spinlock around flushes to avoid bouncing the hypervisor tlbie
487	* lock.	487	* lock.
488	*/	488	*/
489	void pSeries_lpar_flush_hash_range(unsigned long context, unsigned long number,	489	void pSeries_lpar_flush_hash_range(unsigned long context, unsigned long number,
490	int local)	490	int local)
491	{	491	{
492	int i;	492	int i;
493	unsigned long flags = 0;	493	unsigned long flags = 0;
494	struct ppc64_tlb_batch *batch = &__get_cpu_var(ppc64_tlb_batch);	494	struct ppc64_tlb_batch *batch = &__get_cpu_var(ppc64_tlb_batch);
495	int lock_tlbie = !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE);	495	int lock_tlbie = !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE);
496		496
497	if (lock_tlbie)	497	if (lock_tlbie)
498	spin_lock_irqsave(&pSeries_lpar_tlbie_lock, flags);	498	spin_lock_irqsave(&pSeries_lpar_tlbie_lock, flags);
499		499
500	for (i = 0; i < number; i++)	500	for (i = 0; i < number; i++)
501	flush_hash_page(context, batch->addr[i], batch->pte[i], local);	501	flush_hash_page(context, batch->addr[i], batch->pte[i], local);
502		502
503	if (lock_tlbie)	503	if (lock_tlbie)
504	spin_unlock_irqrestore(&pSeries_lpar_tlbie_lock, flags);	504	spin_unlock_irqrestore(&pSeries_lpar_tlbie_lock, flags);
505	}	505	}
506		506
507	void hpte_init_lpar(void)	507	void hpte_init_lpar(void)
508	{	508	{
509	ppc_md.hpte_invalidate = pSeries_lpar_hpte_invalidate;	509	ppc_md.hpte_invalidate = pSeries_lpar_hpte_invalidate;
510	ppc_md.hpte_updatepp = pSeries_lpar_hpte_updatepp;	510	ppc_md.hpte_updatepp = pSeries_lpar_hpte_updatepp;
511	ppc_md.hpte_updateboltedpp = pSeries_lpar_hpte_updateboltedpp;	511	ppc_md.hpte_updateboltedpp = pSeries_lpar_hpte_updateboltedpp;
512	ppc_md.hpte_insert = pSeries_lpar_hpte_insert;	512	ppc_md.hpte_insert = pSeries_lpar_hpte_insert;
513	ppc_md.hpte_remove = pSeries_lpar_hpte_remove;	513	ppc_md.hpte_remove = pSeries_lpar_hpte_remove;
514	ppc_md.flush_hash_range = pSeries_lpar_flush_hash_range;	514	ppc_md.flush_hash_range = pSeries_lpar_flush_hash_range;
515	ppc_md.hpte_clear_all = pSeries_lpar_hptab_clear;	515	ppc_md.hpte_clear_all = pSeries_lpar_hptab_clear;
516		516
517	htab_finish_init();	517	htab_finish_init();
518	}	518	}
519		519

arch/ppc64/kernel/pmac_setup.c

Diff comments View file @ c8f1c8b

 /*
  *  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 "pmac.h"
 #include "mpic.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 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 __pmac 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 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 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 pmac_halt(void)
 {
 	pmac_power_off();
 }
 #ifdef CONFIG_BOOTX_TEXT
 static void btext_putc(unsigned char c)
 {
 	btext_drawchar(c);
 }
 static void __init init_boot_display(void)
 {
 	char *name;
 	struct device_node *np = NULL;
 	int rc = -ENODEV;
 	printk("trying to initialize btext ...\n");
 	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
 	if (name != NULL) {
 		np = of_find_node_by_path(name);
 		if (np != NULL) {
 			if (strcmp(np->type, "display") != 0) {
 				printk("boot stdout isn't a display !\n");
 				of_node_put(np);
 				np = NULL;
 			}
 		}
 	}
 	if (np)
 		rc = btext_initialize(np);
 	if (rc == 0)
 		return;
 	for (np = NULL; (np = of_find_node_by_type(np, "display"));) {
 		if (get_property(np, "linux,opened", NULL)) {
 			printk("trying %s ...\n", np->full_name);
 			rc = btext_initialize(np);
 			printk("result: %d\n", rc);
 		}
 		if (rc == 0)
 			return;
 	}
 }
 #endif /* CONFIG_BOOTX_TEXT */
 /*
  * 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);
        	}
-	else {
 #ifdef CONFIG_BOOTX_TEXT
+	else {
 		init_boot_display();
-		ppc_md.udbg_putc = btext_putc;
+		udbg_putc = btext_putc;
-		ppc_md.udbg_getc = NULL;
-		ppc_md.udbg_getc_poll = NULL;
-#endif /* CONFIG_BOOTX_TEXT */
 	}
+#endif /* CONFIG_BOOTX_TEXT */
 	/* 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;
 	np = find_devices("u3");
 	if (np) {
 		for (np = np->child; np != NULL; np = np->sibling)
 			if (strncmp(np->name, "i2c", 3) == 0) {
 				of_platform_device_create(np, "u3-i2c");
 				break;
 			}
 	}
 	return 0;
 }
 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;
 }
 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,
        	.get_cpuinfo		= pmac_show_cpuinfo,
 	.init_IRQ		= pmac_init_IRQ,
 	.get_irq		= mpic_get_irq,
 	.pcibios_fixup		= pmac_pcibios_fixup,
 	.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,

arch/ppc64/kernel/setup.c

Diff comments View file @ c8f1c8b

 /*
  *
  * Common boot and setup code.
  *
  * Copyright (C) 2001 PPC64 Team, IBM Corp
  *
  *      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/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/seq_file.h>
 #include <linux/ioport.h>
 #include <linux/console.h>
 #include <linux/version.h>
 #include <linux/tty.h>
 #include <linux/root_dev.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/unistd.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/bootinfo.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/machdep.h>
 #include <asm/paca.h>
 #include <asm/ppcdebug.h>
 #include <asm/time.h>
 #include <asm/cputable.h>
 #include <asm/sections.h>
 #include <asm/btext.h>
 #include <asm/nvram.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/rtas.h>
 #include <asm/iommu.h>
 #include <asm/serial.h>
 #include <asm/cache.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 #include <asm/lmb.h>
 #include <asm/iSeries/ItLpNaca.h>
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
 #else
 #define DBG(fmt...)
 #endif
 /*
  * Here are some early debugging facilities. You can enable one
  * but your kernel will not boot on anything else if you do so
  */
 /* This one is for use on LPAR machines that support an HVC console
  * on vterm 0
  */
 extern void udbg_init_debug_lpar(void);
 /* This one is for use on Apple G5 machines
  */
 extern void udbg_init_pmac_realmode(void);
 /* That's RTAS panel debug */
 extern void call_rtas_display_status_delay(unsigned char c);
 /* Here's maple real mode debug */
 extern void udbg_init_maple_realmode(void);
 #define EARLY_DEBUG_INIT() do {} while(0)
 #if 0
 #define EARLY_DEBUG_INIT() udbg_init_debug_lpar()
 #define EARLY_DEBUG_INIT() udbg_init_maple_realmode()
 #define EARLY_DEBUG_INIT() udbg_init_pmac_realmode()
 #define EARLY_DEBUG_INIT()						\
-	do { ppc_md.udbg_putc = call_rtas_display_status_delay; } while(0)
+	do { udbg_putc = call_rtas_display_status_delay; } while(0)
 #endif
 /* extern void *stab; */
 extern unsigned long klimit;
 extern void mm_init_ppc64(void);
 extern void stab_initialize(unsigned long stab);
 extern void htab_initialize(void);
 extern void early_init_devtree(void *flat_dt);
 extern void unflatten_device_tree(void);
 extern void smp_release_cpus(void);
 int have_of = 1;
 int boot_cpuid = 0;
 int boot_cpuid_phys = 0;
 dev_t boot_dev;
 u64 ppc64_pft_size;
 u64 ppc64_debug_switch;
 struct ppc64_caches ppc64_caches;
 EXPORT_SYMBOL_GPL(ppc64_caches);
 /*
  * These are used in binfmt_elf.c to put aux entries on the stack
  * for each elf executable being started.
  */
 int dcache_bsize;
 int icache_bsize;
 int ucache_bsize;
 /* The main machine-dep calls structure
  */
 struct machdep_calls ppc_md;
 EXPORT_SYMBOL(ppc_md);
 #ifdef CONFIG_MAGIC_SYSRQ
 unsigned long SYSRQ_KEY;
 #endif /* CONFIG_MAGIC_SYSRQ */
 static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);
 static struct notifier_block ppc64_panic_block = {
 	.notifier_call = ppc64_panic_event,
 	.priority = INT_MIN /* may not return; must be done last */
 };
 /*
  * Perhaps we can put the pmac screen_info[] here
  * on pmac as well so we don't need the ifdef's.
  * Until we get multiple-console support in here
  * that is.  -- Cort
  * Maybe tie it to serial consoles, since this is really what
  * these processors use on existing boards.  -- Dan
  */
 struct screen_info screen_info = {
 	.orig_x = 0,
 	.orig_y = 25,
 	.orig_video_cols = 80,
 	.orig_video_lines = 25,
 	.orig_video_isVGA = 1,
 	.orig_video_points = 16
 };
 /*
  * Initialize the PPCDBG state.  Called before relocation has been enabled.
  */
 void __init ppcdbg_initialize(void)
 {
 	ppc64_debug_switch = PPC_DEBUG_DEFAULT; /* | PPCDBG_BUSWALK | */
 	/* PPCDBG_PHBINIT | PPCDBG_MM | PPCDBG_MMINIT | PPCDBG_TCEINIT | PPCDBG_TCE */;
 }
 /*
  * Early boot console based on udbg
  */
 static struct console udbg_console = {
 	.name	= "udbg",
 	.write	= udbg_console_write,
 	.flags	= CON_PRINTBUFFER,
 	.index	= -1,
 };
 static int early_console_initialized;
 void __init disable_early_printk(void)
 {
 	if (!early_console_initialized)
 		return;
 	unregister_console(&udbg_console);
 	early_console_initialized = 0;
 }
 #if defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP)
 static int smt_enabled_cmdline;
 /* Look for ibm,smt-enabled OF option */
 static void check_smt_enabled(void)
 {
 	struct device_node *dn;
 	char *smt_option;
 	/* Allow the command line to overrule the OF option */
 	if (smt_enabled_cmdline)
 		return;
 	dn = of_find_node_by_path("/options");
 	if (dn) {
 		smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);
                 if (smt_option) {
 			if (!strcmp(smt_option, "on"))
 				smt_enabled_at_boot = 1;
 			else if (!strcmp(smt_option, "off"))
 				smt_enabled_at_boot = 0;
                 }
         }
 }
 /* Look for smt-enabled= cmdline option */
 static int __init early_smt_enabled(char *p)
 {
 	smt_enabled_cmdline = 1;
 	if (!p)
 		return 0;
 	if (!strcmp(p, "on") || !strcmp(p, "1"))
 		smt_enabled_at_boot = 1;
 	else if (!strcmp(p, "off") || !strcmp(p, "0"))
 		smt_enabled_at_boot = 0;
 	return 0;
 }
 early_param("smt-enabled", early_smt_enabled);
 /**
  * setup_cpu_maps - initialize the following cpu maps:
  *                  cpu_possible_map
  *                  cpu_present_map
  *                  cpu_sibling_map
  *
  * Having the possible map set up early allows us to restrict allocations
  * of things like irqstacks to num_possible_cpus() rather than NR_CPUS.
  *
  * We do not initialize the online map here; cpus set their own bits in
  * cpu_online_map as they come up.
  *
  * This function is valid only for Open Firmware systems.  finish_device_tree
  * must be called before using this.
  *
  * While we're here, we may as well set the "physical" cpu ids in the paca.
  */
 static void __init setup_cpu_maps(void)
 {
 	struct device_node *dn = NULL;
 	int cpu = 0;
 	int swap_cpuid = 0;
 	check_smt_enabled();
 	while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {
 		u32 *intserv;
 		int j, len = sizeof(u32), nthreads;
 		intserv = (u32 *)get_property(dn, "ibm,ppc-interrupt-server#s",
 					      &len);
 		if (!intserv)
 			intserv = (u32 *)get_property(dn, "reg", NULL);
 		nthreads = len / sizeof(u32);
 		for (j = 0; j < nthreads && cpu < NR_CPUS; j++) {
 			cpu_set(cpu, cpu_present_map);
 			set_hard_smp_processor_id(cpu, intserv[j]);
 			if (intserv[j] == boot_cpuid_phys)
 				swap_cpuid = cpu;
 			cpu_set(cpu, cpu_possible_map);
 			cpu++;
 		}
 	}
 	/* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that
 	 * boot cpu is logical 0.
 	 */
 	if (boot_cpuid_phys != get_hard_smp_processor_id(0)) {
 		u32 tmp;
 		tmp = get_hard_smp_processor_id(0);
 		set_hard_smp_processor_id(0, boot_cpuid_phys);
 		set_hard_smp_processor_id(swap_cpuid, tmp);
 	}
 	/*
 	 * On pSeries LPAR, we need to know how many cpus
 	 * could possibly be added to this partition.
 	 */
 	if (systemcfg->platform == PLATFORM_PSERIES_LPAR &&
 				(dn = of_find_node_by_path("/rtas"))) {
 		int num_addr_cell, num_size_cell, maxcpus;
 		unsigned int *ireg;
 		num_addr_cell = prom_n_addr_cells(dn);
 		num_size_cell = prom_n_size_cells(dn);
 		ireg = (unsigned int *)
 			get_property(dn, "ibm,lrdr-capacity", NULL);
 		if (!ireg)
 			goto out;
 		maxcpus = ireg[num_addr_cell + num_size_cell];
 		/* Double maxcpus for processors which have SMT capability */
 		if (cpu_has_feature(CPU_FTR_SMT))
 			maxcpus *= 2;
 		if (maxcpus > NR_CPUS) {
 			printk(KERN_WARNING
 			       "Partition configured for %d cpus, "
 			       "operating system maximum is %d.\n",
 			       maxcpus, NR_CPUS);
 			maxcpus = NR_CPUS;
 		} else
 			printk(KERN_INFO "Partition configured for %d cpus.\n",
 			       maxcpus);
 		for (cpu = 0; cpu < maxcpus; cpu++)
 			cpu_set(cpu, cpu_possible_map);
 	out:
 		of_node_put(dn);
 	}
 	/*
 	 * Do the sibling map; assume only two threads per processor.
 	 */
 	for_each_cpu(cpu) {
 		cpu_set(cpu, cpu_sibling_map[cpu]);
 		if (cpu_has_feature(CPU_FTR_SMT))
 			cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]);
 	}
 	systemcfg->processorCount = num_present_cpus();
 }
 #endif /* defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP) */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 extern struct machdep_calls pSeries_md;
 extern struct machdep_calls pmac_md;
 extern struct machdep_calls maple_md;
 extern struct machdep_calls bpa_md;
 /* Ultimately, stuff them in an elf section like initcalls... */
 static struct machdep_calls __initdata *machines[] = {
 #ifdef CONFIG_PPC_PSERIES
 	&pSeries_md,
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_PPC_PMAC
 	&pmac_md,
 #endif /* CONFIG_PPC_PMAC */
 #ifdef CONFIG_PPC_MAPLE
 	&maple_md,
 #endif /* CONFIG_PPC_MAPLE */
 #ifdef CONFIG_PPC_BPA
 	&bpa_md,
 #endif
 	NULL
 };
 /*
  * Early initialization entry point. This is called by head.S
  * with MMU translation disabled. We rely on the "feature" of
  * the CPU that ignores the top 2 bits of the address in real
  * mode so we can access kernel globals normally provided we
  * only toy with things in the RMO region. From here, we do
  * some early parsing of the device-tree to setup out LMB
  * data structures, and allocate & initialize the hash table
  * and segment tables so we can start running with translation
  * enabled.
  *
  * It is this function which will call the probe() callback of
  * the various platform types and copy the matching one to the
  * global ppc_md structure. Your platform can eventually do
  * some very early initializations from the probe() routine, but
  * this is not recommended, be very careful as, for example, the
  * device-tree is not accessible via normal means at this point.
  */
 void __init early_setup(unsigned long dt_ptr)
 {
 	struct paca_struct *lpaca = get_paca();
 	static struct machdep_calls **mach;
 	/*
 	 * Enable early debugging if any specified (see top of
 	 * this file)
 	 */
 	EARLY_DEBUG_INIT();
 	DBG(" -> early_setup()\n");
 	/*
 	 * Fill the default DBG level (do we want to keep
 	 * that old mecanism around forever ?)
 	 */
 	ppcdbg_initialize();
 	/*
 	 * Do early initializations using the flattened device
 	 * tree, like retreiving the physical memory map or
 	 * calculating/retreiving the hash table size
 	 */
 	early_init_devtree(__va(dt_ptr));
 	/*
 	 * Iterate all ppc_md structures until we find the proper
 	 * one for the current machine type
 	 */
 	DBG("Probing machine type for platform %x...\n",
 	    systemcfg->platform);
 	for (mach = machines; *mach; mach++) {
 		if ((*mach)->probe(systemcfg->platform))
 			break;
 	}
 	/* What can we do if we didn't find ? */
 	if (*mach == NULL) {
 		DBG("No suitable machine found !\n");
 		for (;;);
 	}
 	ppc_md = **mach;
-	/* our udbg callbacks got overriden by the above, let's put them
-	 * back in. Ultimately, I want those things to be split from the
-	 * main ppc_md
-	 */
-	EARLY_DEBUG_INIT();
 	DBG("Found, Initializing memory management...\n");
 	/*
 	 * Initialize stab / SLB management
 	 */
 	stab_initialize(lpaca->stab_real);
 	/*
 	 * Initialize the MMU Hash table and create the linear mapping
 	 * of memory
 	 */
 	htab_initialize();
 	DBG(" <- early_setup()\n");
 }
 /*
  * Initialize some remaining members of the ppc64_caches and systemcfg structures
  * (at least until we get rid of them completely). This is mostly some
  * cache informations about the CPU that will be used by cache flush
  * routines and/or provided to userland
  */
 static void __init initialize_cache_info(void)
 {
 	struct device_node *np;
 	unsigned long num_cpus = 0;
 	DBG(" -> initialize_cache_info()\n");
 	for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {
 		num_cpus += 1;
 		/* We're assuming *all* of the CPUs have the same
 		 * d-cache and i-cache sizes... -Peter
 		 */
 		if ( num_cpus == 1 ) {
 			u32 *sizep, *lsizep;
 			u32 size, lsize;
 			const char *dc, *ic;
 			/* Then read cache informations */
 			if (systemcfg->platform == PLATFORM_POWERMAC) {
 				dc = "d-cache-block-size";
 				ic = "i-cache-block-size";
 			} else {
 				dc = "d-cache-line-size";
 				ic = "i-cache-line-size";
 			}
 			size = 0;
 			lsize = cur_cpu_spec->dcache_bsize;
 			sizep = (u32 *)get_property(np, "d-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *) get_property(np, dc, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find dcache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->dcache_size = ppc64_caches.dsize = size;
 			systemcfg->dcache_line_size =
 				ppc64_caches.dline_size = lsize;
 			ppc64_caches.log_dline_size = __ilog2(lsize);
 			ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;
 			size = 0;
 			lsize = cur_cpu_spec->icache_bsize;
 			sizep = (u32 *)get_property(np, "i-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *)get_property(np, ic, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find icache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->icache_size = ppc64_caches.isize = size;
 			systemcfg->icache_line_size =
 				ppc64_caches.iline_size = lsize;
 			ppc64_caches.log_iline_size = __ilog2(lsize);
 			ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;
 		}
 	}
 	/* Add an eye catcher and the systemcfg layout version number */
 	strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64");
 	systemcfg->version.major = SYSTEMCFG_MAJOR;
 	systemcfg->version.minor = SYSTEMCFG_MINOR;
 	systemcfg->processor = mfspr(SPRN_PVR);
 	DBG(" <- initialize_cache_info()\n");
 }
 static void __init check_for_initrd(void)
 {
 #ifdef CONFIG_BLK_DEV_INITRD
 	u64 *prop;
 	DBG(" -> check_for_initrd()\n");
 	if (of_chosen) {
 		prop = (u64 *)get_property(of_chosen,
 				"linux,initrd-start", NULL);
 		if (prop != NULL) {
 			initrd_start = (unsigned long)__va(*prop);
 			prop = (u64 *)get_property(of_chosen,
 					"linux,initrd-end", NULL);
 			if (prop != NULL) {
 				initrd_end = (unsigned long)__va(*prop);
 				initrd_below_start_ok = 1;
 			} else
 				initrd_start = 0;
 		}
 	}
 	/* If we were passed an initrd, set the ROOT_DEV properly if the values
 	 * look sensible. If not, clear initrd reference.
 	 */
 	if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
 	    initrd_end > initrd_start)
 		ROOT_DEV = Root_RAM0;
 	else
 		initrd_start = initrd_end = 0;
 	if (initrd_start)
 		printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);
 	DBG(" <- check_for_initrd()\n");
 #endif /* CONFIG_BLK_DEV_INITRD */
 }
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 /*
  * Do some initial setup of the system.  The parameters are those which
  * were passed in from the bootloader.
  */
 void __init setup_system(void)
 {
 	DBG(" -> setup_system()\n");
 #ifdef CONFIG_PPC_ISERIES
 	/* pSeries systems are identified in prom.c via OF. */
 	if (itLpNaca.xLparInstalled == 1)
 		systemcfg->platform = PLATFORM_ISERIES_LPAR;
 	ppc_md.init_early();
 #else /* CONFIG_PPC_ISERIES */
 	/*
 	 * Unflatten the device-tree passed by prom_init or kexec
 	 */
 	unflatten_device_tree();
 	/*
 	 * Fill the ppc64_caches & systemcfg structures with informations
 	 * retreived from the device-tree. Need to be called before
 	 * finish_device_tree() since the later requires some of the
 	 * informations filled up here to properly parse the interrupt
 	 * tree.
 	 * It also sets up the cache line sizes which allows to call
 	 * routines like flush_icache_range (used by the hash init
 	 * later on).
 	 */
 	initialize_cache_info();
 #ifdef CONFIG_PPC_RTAS
 	/*
 	 * Initialize RTAS if available
 	 */
 	rtas_initialize();
 #endif /* CONFIG_PPC_RTAS */
 	/*
 	 * Check if we have an initrd provided via the device-tree
 	 */
 	check_for_initrd();
 	/*
 	 * Do some platform specific early initializations, that includes
 	 * setting up the hash table pointers. It also sets up some interrupt-mapping
 	 * related options that will be used by finish_device_tree()
 	 */
 	ppc_md.init_early();
 	/*
 	 * "Finish" the device-tree, that is do the actual parsing of
 	 * some of the properties like the interrupt map
 	 */
 	finish_device_tree();
 	/*
 	 * Initialize xmon
 	 */
 #ifdef CONFIG_XMON_DEFAULT
 	xmon_init(1);
 #endif
 	/*
 	 * Register early console
 	 */
 	early_console_initialized = 1;
 	register_console(&udbg_console);
 	/* Save unparsed command line copy for /proc/cmdline */
 	strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
 	parse_early_param();
 #endif /* !CONFIG_PPC_ISERIES */
 #if defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES)
 	/*
 	 * iSeries has already initialized the cpu maps at this point.
 	 */
 	setup_cpu_maps();
 	/* Release secondary cpus out of their spinloops at 0x60 now that
 	 * we can map physical -> logical CPU ids
 	 */
 	smp_release_cpus();
 #endif /* defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) */
 	printk("Starting Linux PPC64 %s\n", UTS_RELEASE);
 	printk("-----------------------------------------------------\n");
 	printk("ppc64_pft_size                = 0x%lx\n", ppc64_pft_size);
 	printk("ppc64_debug_switch            = 0x%lx\n", ppc64_debug_switch);
 	printk("ppc64_interrupt_controller    = 0x%ld\n", ppc64_interrupt_controller);
 	printk("systemcfg                     = 0x%p\n", systemcfg);
 	printk("systemcfg->platform           = 0x%x\n", systemcfg->platform);
 	printk("systemcfg->processorCount     = 0x%lx\n", systemcfg->processorCount);
 	printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize);
 	printk("ppc64_caches.dcache_line_size = 0x%x\n",
 			ppc64_caches.dline_size);
 	printk("ppc64_caches.icache_line_size = 0x%x\n",
 			ppc64_caches.iline_size);
 	printk("htab_address                  = 0x%p\n", htab_address);
 	printk("htab_hash_mask                = 0x%lx\n", htab_hash_mask);
 	printk("-----------------------------------------------------\n");
 	mm_init_ppc64();
 	DBG(" <- setup_system()\n");
 }
 /* also used by kexec */
 void machine_shutdown(void)
 {
 	if (ppc_md.nvram_sync)
 		ppc_md.nvram_sync();
 }
 void machine_restart(char *cmd)
 {
 	machine_shutdown();
 	ppc_md.restart(cmd);
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 void machine_power_off(void)
 {
 	machine_shutdown();
 	ppc_md.power_off();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 /* Used by the G5 thermal driver */
 EXPORT_SYMBOL_GPL(machine_power_off);
 void machine_halt(void)
 {
 	machine_shutdown();
 	ppc_md.halt();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 static int ppc64_panic_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
 	ppc_md.panic((char *)ptr);  /* May not return */
 	return NOTIFY_DONE;
 }
 #ifdef CONFIG_SMP
 DEFINE_PER_CPU(unsigned int, pvr);
 #endif
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
 	unsigned long cpu_id = (unsigned long)v - 1;
 	unsigned int pvr;
 	unsigned short maj;
 	unsigned short min;
 	if (cpu_id == NR_CPUS) {
 		seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);
 		if (ppc_md.get_cpuinfo != NULL)
 			ppc_md.get_cpuinfo(m);
 		return 0;
 	}
 	/* We only show online cpus: disable preempt (overzealous, I
 	 * knew) to prevent cpu going down. */
 	preempt_disable();
 	if (!cpu_online(cpu_id)) {
 		preempt_enable();
 		return 0;
 	}
 #ifdef CONFIG_SMP
 	pvr = per_cpu(pvr, cpu_id);
 #else
 	pvr = mfspr(SPRN_PVR);
 #endif
 	maj = (pvr >> 8) & 0xFF;
 	min = pvr & 0xFF;
 	seq_printf(m, "processor\t: %lu\n", cpu_id);
 	seq_printf(m, "cpu\t\t: ");
 	if (cur_cpu_spec->pvr_mask)
 		seq_printf(m, "%s", cur_cpu_spec->cpu_name);
 	else
 		seq_printf(m, "unknown (%08x)", pvr);
 #ifdef CONFIG_ALTIVEC
 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
 		seq_printf(m, ", altivec supported");
 #endif /* CONFIG_ALTIVEC */
 	seq_printf(m, "\n");
 	/*
 	 * Assume here that all clock rates are the same in a
 	 * smp system.  -- Cort
 	 */
 	seq_printf(m, "clock\t\t: %lu.%06luMHz\n", ppc_proc_freq / 1000000,
 		   ppc_proc_freq % 1000000);
 	seq_printf(m, "revision\t: %hd.%hd\n\n", maj, min);
 	preempt_enable();
 	return 0;
 }
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	return *pos <= NR_CPUS ? (void *)((*pos)+1) : NULL;
 }
 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return c_start(m, pos);
 }
 static void c_stop(struct seq_file *m, void *v)
 {
 }
 struct seq_operations cpuinfo_op = {
 	.start =c_start,
 	.next =	c_next,
 	.stop =	c_stop,
 	.show =	show_cpuinfo,
 };
 /*
  * These three variables are used to save values passed to us by prom_init()
  * via the device tree. The TCE variables are needed because with a memory_limit
  * in force we may need to explicitly map the TCE are at the top of RAM.
  */
 unsigned long memory_limit;
 unsigned long tce_alloc_start;
 unsigned long tce_alloc_end;
 #ifdef CONFIG_PPC_ISERIES
 /*
  * On iSeries we just parse the mem=X option from the command line.
  * On pSeries it's a bit more complicated, see prom_init_mem()
  */
 static int __init early_parsemem(char *p)
 {
 	if (!p)
 		return 0;
 	memory_limit = ALIGN(memparse(p, &p), PAGE_SIZE);
 	return 0;
 }
 early_param("mem", early_parsemem);
 #endif /* CONFIG_PPC_ISERIES */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static int __init set_preferred_console(void)
 {
 	struct device_node *prom_stdout = NULL;
 	char *name;
 	u32 *spd;
 	int offset = 0;
 	DBG(" -> set_preferred_console()\n");
 	/* The user has requested a console so this is already set up. */
 	if (strstr(saved_command_line, "console=")) {
 		DBG(" console was specified !\n");
 		return -EBUSY;
 	}
 	if (!of_chosen) {
 		DBG(" of_chosen is NULL !\n");
 		return -ENODEV;
 	}
 	/* We are getting a weird phandle from OF ... */
 	/* ... So use the full path instead */
 	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
 	if (name == NULL) {
 		DBG(" no linux,stdout-path !\n");
 		return -ENODEV;
 	}
 	prom_stdout = of_find_node_by_path(name);
 	if (!prom_stdout) {
 		DBG(" can't find stdout package %s !\n", name);
 		return -ENODEV;
 	}
 	DBG("stdout is %s\n", prom_stdout->full_name);
 	name = (char *)get_property(prom_stdout, "name", NULL);
 	if (!name) {
 		DBG(" stdout package has no name !\n");
 		goto not_found;
 	}
 	spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);
 	if (0)
 		;
 #ifdef CONFIG_SERIAL_8250_CONSOLE
 	else if (strcmp(name, "serial") == 0) {
 		int i;
 		u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);
 		if (i > 8) {
 			switch (reg[1]) {
 				case 0x3f8:
 					offset = 0;
 					break;
 				case 0x2f8:
 					offset = 1;
 					break;
 				case 0x898:
 					offset = 2;
 					break;
 				case 0x890:
 					offset = 3;
 					break;
 				default:
 					/* We dont recognise the serial port */
 					goto not_found;
 			}
 		}
 	}
 #endif /* CONFIG_SERIAL_8250_CONSOLE */
 #ifdef CONFIG_PPC_PSERIES
 	else if (strcmp(name, "vty") == 0) {
  		u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL);
  		char *compat = (char *)get_property(prom_stdout, "compatible", NULL);
  		if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) {
  			/* Host Virtual Serial Interface */
  			int offset;
  			switch (reg[0]) {
  				case 0x30000000:
  					offset = 0;
  					break;
  				case 0x30000001:
  					offset = 1;
  					break;
  				default:
 					goto not_found;
  			}
 			of_node_put(prom_stdout);
 			DBG("Found hvsi console at offset %d\n", offset);
  			return add_preferred_console("hvsi", offset, NULL);
  		} else {
  			/* pSeries LPAR virtual console */
 			of_node_put(prom_stdout);
 			DBG("Found hvc console\n");
  			return add_preferred_console("hvc", 0, NULL);
  		}
 	}
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
 	else if (strcmp(name, "ch-a") == 0)
 		offset = 0;
 	else if (strcmp(name, "ch-b") == 0)
 		offset = 1;
 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
 	else
 		goto not_found;
 	of_node_put(prom_stdout);
 	DBG("Found serial console at ttyS%d\n", offset);
 	if (spd) {
 		static char __initdata opt[16];
 		sprintf(opt, "%d", *spd);
 		return add_preferred_console("ttyS", offset, opt);
 	} else
 		return add_preferred_console("ttyS", offset, NULL);
  not_found:
 	DBG("No preferred console found !\n");
 	of_node_put(prom_stdout);
 	return -ENODEV;
 }
 console_initcall(set_preferred_console);
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 #ifdef CONFIG_IRQSTACKS
 static void __init irqstack_early_init(void)
 {
 	unsigned int i;
 	/*
 	 * interrupt stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them.
 	 */
 	for_each_cpu(i) {
 		softirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,
 					THREAD_SIZE, 0x10000000));
 		hardirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,
 					THREAD_SIZE, 0x10000000));
 	}
 }
 #else
 #define irqstack_early_init()
 #endif
 /*
  * Stack space used when we detect a bad kernel stack pointer, and
  * early in SMP boots before relocation is enabled.
  */
 static void __init emergency_stack_init(void)
 {
 	unsigned long limit;
 	unsigned int i;
 	/*
 	 * Emergency stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them. The ABI also requires them to be 128-byte
 	 * aligned.
 	 *
 	 * Since we use these as temporary stacks during secondary CPU
 	 * bringup, we need to get at them in real mode. This means they
 	 * must also be within the RMO region.
 	 */
 	limit = min(0x10000000UL, lmb.rmo_size);
 	for_each_cpu(i)
 		paca[i].emergency_sp = __va(lmb_alloc_base(PAGE_SIZE, 128,
 						limit)) + PAGE_SIZE;
 }
 /*
  * Called from setup_arch to initialize the bitmap of available
  * syscalls in the systemcfg page
  */
 void __init setup_syscall_map(void)
 {
 	unsigned int i, count64 = 0, count32 = 0;
 	extern unsigned long *sys_call_table;
 	extern unsigned long *sys_call_table32;
 	extern unsigned long sys_ni_syscall;
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table[i] == sys_ni_syscall)
 			continue;
 		count64++;
 		systemcfg->syscall_map_64[i >> 5] |= 0x80000000UL >> (i & 0x1f);
 	}
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table32[i] == sys_ni_syscall)
 			continue;
 		count32++;
 		systemcfg->syscall_map_32[i >> 5] |= 0x80000000UL >> (i & 0x1f);
 	}
 	printk(KERN_INFO "Syscall map setup, %d 32 bits and %d 64 bits syscalls\n",
 	       count32, count64);
 }
 /*
  * Called into from start_kernel, after lock_kernel has been called.
  * Initializes bootmem, which is unsed to manage page allocation until
  * mem_init is called.
  */
 void __init setup_arch(char **cmdline_p)
 {
 	extern void do_init_bootmem(void);
 	ppc64_boot_msg(0x12, "Setup Arch");
 	*cmdline_p = cmd_line;
 	/*
 	 * Set cache line size based on type of cpu as a default.
 	 * Systems with OF can look in the properties on the cpu node(s)
 	 * for a possibly more accurate value.
 	 */
 	dcache_bsize = ppc64_caches.dline_size;
 	icache_bsize = ppc64_caches.iline_size;
 	/* reboot on panic */
 	panic_timeout = 180;
 	if (ppc_md.panic)
 		notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) _etext;
 	init_mm.end_data = (unsigned long) _edata;
 	init_mm.brk = klimit;
 	irqstack_early_init();
 	emergency_stack_init();
 	stabs_alloc();
 	/* set up the bootmem stuff with available memory */
 	do_init_bootmem();
 	sparse_init();
 	/* initialize the syscall map in systemcfg */
 	setup_syscall_map();
 	ppc_md.setup_arch();
 	/* Use the default idle loop if the platform hasn't provided one. */
 	if (NULL == ppc_md.idle_loop) {
 		ppc_md.idle_loop = default_idle;
 		printk(KERN_INFO "Using default idle loop\n");
 	}
 	paging_init();
 	ppc64_boot_msg(0x15, "Setup Done");
 }
 /* ToDo: do something useful if ppc_md is not yet setup. */
 #define PPC64_LINUX_FUNCTION 0x0f000000
 #define PPC64_IPL_MESSAGE 0xc0000000
 #define PPC64_TERM_MESSAGE 0xb0000000
 #define PPC64_ATTN_MESSAGE 0xa0000000
 #define PPC64_DUMP_MESSAGE 0xd0000000
 static void ppc64_do_msg(unsigned int src, const char *msg)
 {
 	if (ppc_md.progress) {
 		char buf[128];
 		sprintf(buf, "%08X\n", src);
 		ppc_md.progress(buf, 0);
 		snprintf(buf, 128, "%s", msg);
 		ppc_md.progress(buf, 0);
 	}
 }
 /* Print a boot progress message. */
 void ppc64_boot_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);
 	printk("[boot]%04x %s\n", src, msg);
 }
 /* Print a termination message (print only -- does not stop the kernel) */
 void ppc64_terminate_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg);
 	printk("[terminate]%04x %s\n", src, msg);
 }
 /* Print something that needs attention (device error, etc) */
 void ppc64_attention_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_ATTN_MESSAGE|src, msg);
 	printk("[attention]%04x %s\n", src, msg);
 }
 /* Print a dump progress message. */
 void ppc64_dump_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_DUMP_MESSAGE|src, msg);
 	printk("[dump]%04x %s\n", src, msg);
 }
 /* This should only be called on processor 0 during calibrate decr */
 void __init setup_default_decr(void)
 {
 	struct paca_struct *lpaca = get_paca();
 	lpaca->default_decr = tb_ticks_per_jiffy;
 	lpaca->next_jiffy_update_tb = get_tb() + tb_ticks_per_jiffy;
 }
 #ifndef CONFIG_PPC_ISERIES
 /*
  * This function can be used by platforms to "find" legacy serial ports.
  * It works for "serial" nodes under an "isa" node, and will try to
  * respect the "ibm,aix-loc" property if any. It works with up to 8
  * ports.
  */
 #define MAX_LEGACY_SERIAL_PORTS	8
 static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1];
 static unsigned int old_serial_count;
 void __init generic_find_legacy_serial_ports(u64 *physport,
 		unsigned int *default_speed)
 {
 	struct device_node *np;
 	u32 *sizeprop;
 	struct isa_reg_property {
 		u32 space;
 		u32 address;
 		u32 size;
 	};
 	struct pci_reg_property {
 		struct pci_address addr;
 		u32 size_hi;
 		u32 size_lo;
 	};
 	DBG(" -> generic_find_legacy_serial_port()\n");
 	*physport = 0;
 	if (default_speed)
 		*default_speed = 0;
 	np = of_find_node_by_path("/");
 	if (!np)
 		return;
 	/* First fill our array */
 	for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {
 		struct device_node *isa, *pci;
 		struct isa_reg_property *reg;
 		unsigned long phys_size, addr_size, io_base;
 		u32 *rangesp;
 		u32 *interrupts, *clk, *spd;
 		char *typep;
 		int index, rlen, rentsize;
 		/* Ok, first check if it's under an "isa" parent */
 		isa = of_get_parent(np);
 		if (!isa || strcmp(isa->name, "isa")) {
 			DBG("%s: no isa parent found\n", np->full_name);
 			continue;
 		}
 		/* Now look for an "ibm,aix-loc" property that gives us ordering
 		 * if any...
 		 */
 	 	typep = (char *)get_property(np, "ibm,aix-loc", NULL);
 		/* Get the ISA port number */
 		reg = (struct isa_reg_property *)get_property(np, "reg", NULL);
 		if (reg == NULL)
 			goto next_port;
 		/* We assume the interrupt number isn't translated ... */
 		interrupts = (u32 *)get_property(np, "interrupts", NULL);
 		/* get clock freq. if present */
 		clk = (u32 *)get_property(np, "clock-frequency", NULL);
 		/* get default speed if present */
 		spd = (u32 *)get_property(np, "current-speed", NULL);
 		/* Default to locate at end of array */
 		index = old_serial_count; /* end of the array by default */
 		/* If we have a location index, then use it */
 		if (typep && *typep == 'S') {
 			index = simple_strtol(typep+1, NULL, 0) - 1;
 			/* if index is out of range, use end of array instead */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				index = old_serial_count;
 			/* if our index is still out of range, that mean that
 			 * array is full, we could scan for a free slot but that
 			 * make little sense to bother, just skip the port
 			 */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				goto next_port;
 			if (index >= old_serial_count)
 				old_serial_count = index + 1;
 			/* Check if there is a port who already claimed our slot */
 			if (serial_ports[index].iobase != 0) {
 				/* if we still have some room, move it, else override */
 				if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) {
 					DBG("Moved legacy port %d -> %d\n", index,
 					    old_serial_count);
 					serial_ports[old_serial_count++] =
 						serial_ports[index];
 				} else {
 					DBG("Replacing legacy port %d\n", index);
 				}
 			}
 		}
 		if (index >= MAX_LEGACY_SERIAL_PORTS)
 			goto next_port;
 		if (index >= old_serial_count)
 			old_serial_count = index + 1;
 		/* Now fill the entry */
 		memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port));
 		serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16;
 		serial_ports[index].iobase = reg->address;
 		serial_ports[index].irq = interrupts ? interrupts[0] : 0;
 		serial_ports[index].flags = ASYNC_BOOT_AUTOCONF;
 		DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n",
 		    index,
 		    serial_ports[index].iobase,
 		    serial_ports[index].irq,
 		    serial_ports[index].uartclk);
 		/* Get phys address of IO reg for port 1 */
 		if (index != 0)
 			goto next_port;
 		pci = of_get_parent(isa);
 		if (!pci) {
 			DBG("%s: no pci parent found\n", np->full_name);
 			goto next_port;
 		}
 		rangesp = (u32 *)get_property(pci, "ranges", &rlen);
 		if (rangesp == NULL) {
 			of_node_put(pci);
 			goto next_port;
 		}
 		rlen /= 4;
 		/* we need the #size-cells of the PCI bridge node itself */
 		phys_size = 1;
 		sizeprop = (u32 *)get_property(pci, "#size-cells", NULL);
 		if (sizeprop != NULL)
 			phys_size = *sizeprop;
 		/* we need the parent #addr-cells */
 		addr_size = prom_n_addr_cells(pci);
 		rentsize = 3 + addr_size + phys_size;
 		io_base = 0;
 		for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) {
 			if (((rangesp[0] >> 24) & 0x3) != 1)
 				continue; /* not IO space */
 			io_base = rangesp[3];
 			if (addr_size == 2)
 				io_base = (io_base << 32) | rangesp[4];
 		}
 		if (io_base != 0) {
 			*physport = io_base + reg->address;
 			if (default_speed && spd)
 				*default_speed = *spd;
 		}
 		of_node_put(pci);
 	next_port:
 		of_node_put(isa);
 	}
 	DBG(" <- generic_find_legacy_serial_port()\n");
 }
 static struct platform_device serial_device = {
 	.name	= "serial8250",
 	.id	= 0,
 	.dev	= {
 		.platform_data = serial_ports,
 	},
 };
 static int __init serial_dev_init(void)
 {
 	return platform_device_register(&serial_device);
 }
 arch_initcall(serial_dev_init);
 #endif /* CONFIG_PPC_ISERIES */
 int check_legacy_ioport(unsigned long base_port)
 {
 	if (ppc_md.check_legacy_ioport == NULL)
 		return 0;
 	return ppc_md.check_legacy_ioport(base_port);
 }
 EXPORT_SYMBOL(check_legacy_ioport);
 #ifdef CONFIG_XMON
 static int __init early_xmon(char *p)
 {
 	/* ensure xmon is enabled */
 	if (p) {
 		if (strncmp(p, "on", 2) == 0)
 			xmon_init(1);
 		if (strncmp(p, "off", 3) == 0)
 			xmon_init(0);
 		if (strncmp(p, "early", 5) != 0)
 			return 0;
 	}
 	xmon_init(1);
 	debugger(NULL);
 	return 0;
 }
 early_param("xmon", early_xmon);
 #endif
 void cpu_die(void)
 {
 	if (ppc_md.cpu_die)
 		ppc_md.cpu_die();
 }

arch/ppc64/kernel/udbg.c

Diff comments View file @ c8f1c8b

 /*
  * polling mode stateless debugging stuff, originally for NS16550 Serial Ports
  *
  * c 2001 PPC 64 Team, IBM Corp
  *
  *      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 <stdarg.h>
 #define WANT_PPCDBG_TAB /* Only defined here */
 #include <linux/config.h>
 #include <linux/types.h>
 #include <asm/ppcdebug.h>
 #include <asm/processor.h>
 #include <asm/uaccess.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
 #include <asm/prom.h>
+void (*udbg_putc)(unsigned char c);
+unsigned char (*udbg_getc)(void);
+int (*udbg_getc_poll)(void);
 void udbg_puts(const char *s)
 {
-	if (ppc_md.udbg_putc) {
+	if (udbg_putc) {
 		char c;
 		if (s && *s != '\0') {
 			while ((c = *s++) != '\0')
-				ppc_md.udbg_putc(c);
+				udbg_putc(c);
 		}
 	}
 #if 0
 	else {
 		printk("%s", s);
 	}
 #endif
 }
 int udbg_write(const char *s, int n)
 {
 	int remain = n;
 	char c;
-	if (!ppc_md.udbg_putc)
+	if (!udbg_putc)
 		return 0;
 	if (s && *s != '\0') {
 		while (((c = *s++) != '\0') && (remain-- > 0)) {
-			ppc_md.udbg_putc(c);
+			udbg_putc(c);
 		}
 	}
 	return n - remain;
 }
 int udbg_read(char *buf, int buflen)
 {
 	char c, *p = buf;
 	int i;
-	if (!ppc_md.udbg_getc)
+	if (!udbg_getc)
 		return 0;
 	for (i = 0; i < buflen; ++i) {
 		do {
-			c = ppc_md.udbg_getc();
+			c = udbg_getc();
 		} while (c == 0x11 || c == 0x13);
 		if (c == 0)
 			break;
 		*p++ = c;
 	}
 	return i;
 }
 void udbg_console_write(struct console *con, const char *s, unsigned int n)
 {
 	udbg_write(s, n);
 }
 #define UDBG_BUFSIZE 256
 void udbg_printf(const char *fmt, ...)
 {
 	unsigned char buf[UDBG_BUFSIZE];
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(buf, UDBG_BUFSIZE, fmt, args);
 	udbg_puts(buf);
 	va_end(args);
 }
 /* Special print used by PPCDBG() macro */
 void udbg_ppcdbg(unsigned long debug_flags, const char *fmt, ...)
 {
 	unsigned long active_debugs = debug_flags & ppc64_debug_switch;
 	if (active_debugs) {
 		va_list ap;
 		unsigned char buf[UDBG_BUFSIZE];
 		unsigned long i, len = 0;
 		for (i=0; i < PPCDBG_NUM_FLAGS; i++) {
 			if (((1U << i) & active_debugs) &&
 			    trace_names[i]) {
 				len += strlen(trace_names[i]);
 				udbg_puts(trace_names[i]);
 				break;
 			}
 		}
 		snprintf(buf, UDBG_BUFSIZE, " [%s]: ", current->comm);
 		len += strlen(buf);
 		udbg_puts(buf);
 		while (len < 18) {
 			udbg_puts(" ");
 			len++;
 		}
 		va_start(ap, fmt);
 		vsnprintf(buf, UDBG_BUFSIZE, fmt, ap);
 		udbg_puts(buf);
 		va_end(ap);
 	}
 }
 unsigned long udbg_ifdebug(unsigned long flags)
 {
 	return (flags & ppc64_debug_switch);
 }

arch/ppc64/kernel/udbg_16550.c

Diff comments View file @ c8f1c8b

1	/*	1	/*
2	* udbg for for NS16550 compatable serial ports	2	* udbg for for NS16550 compatable serial ports
3	*	3	*
4	* Copyright (C) 2001-2005 PPC 64 Team, IBM Corp	4	* Copyright (C) 2001-2005 PPC 64 Team, IBM Corp
5	*	5	*
6	* This program is free software; you can redistribute it and/or	6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License	7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version	8	* as published by the Free Software Foundation; either version
9	* 2 of the License, or (at your option) any later version.	9	* 2 of the License, or (at your option) any later version.
10	*/	10	*/
11	#include <linux/config.h>	11	#include <linux/config.h>
12	#include <linux/types.h>	12	#include <linux/types.h>
13	#include <asm/ppcdebug.h>	13	#include <asm/ppcdebug.h>
14	#include <asm/processor.h>	14	#include <asm/processor.h>
15	#include <asm/naca.h>	15	#include <asm/naca.h>
16	#include <asm/uaccess.h>	16	#include <asm/uaccess.h>
17	#include <asm/machdep.h>	17	#include <asm/machdep.h>
18	#include <asm/io.h>	18	#include <asm/io.h>
19	#include <asm/prom.h>	19	#include <asm/prom.h>
20		20
21	extern u8 real_readb(volatile u8 __iomem *addr);	21	extern u8 real_readb(volatile u8 __iomem *addr);
22	extern void real_writeb(u8 data, volatile u8 __iomem *addr);	22	extern void real_writeb(u8 data, volatile u8 __iomem *addr);
23		23
24	struct NS16550 {	24	struct NS16550 {
25	/* this struct must be packed */	25	/* this struct must be packed */
26	unsigned char rbr; /* 0 */	26	unsigned char rbr; /* 0 */
27	unsigned char ier; /* 1 */	27	unsigned char ier; /* 1 */
28	unsigned char fcr; /* 2 */	28	unsigned char fcr; /* 2 */
29	unsigned char lcr; /* 3 */	29	unsigned char lcr; /* 3 */
30	unsigned char mcr; /* 4 */	30	unsigned char mcr; /* 4 */
31	unsigned char lsr; /* 5 */	31	unsigned char lsr; /* 5 */
32	unsigned char msr; /* 6 */	32	unsigned char msr; /* 6 */
33	unsigned char scr; /* 7 */	33	unsigned char scr; /* 7 */
34	};	34	};
35		35
36	#define thr rbr	36	#define thr rbr
37	#define iir fcr	37	#define iir fcr
38	#define dll rbr	38	#define dll rbr
39	#define dlm ier	39	#define dlm ier
40	#define dlab lcr	40	#define dlab lcr
41		41
42	#define LSR_DR 0x01 /* Data ready */	42	#define LSR_DR 0x01 /* Data ready */
43	#define LSR_OE 0x02 /* Overrun */	43	#define LSR_OE 0x02 /* Overrun */
44	#define LSR_PE 0x04 /* Parity error */	44	#define LSR_PE 0x04 /* Parity error */
45	#define LSR_FE 0x08 /* Framing error */	45	#define LSR_FE 0x08 /* Framing error */
46	#define LSR_BI 0x10 /* Break */	46	#define LSR_BI 0x10 /* Break */
47	#define LSR_THRE 0x20 /* Xmit holding register empty */	47	#define LSR_THRE 0x20 /* Xmit holding register empty */
48	#define LSR_TEMT 0x40 /* Xmitter empty */	48	#define LSR_TEMT 0x40 /* Xmitter empty */
49	#define LSR_ERR 0x80 /* Error */	49	#define LSR_ERR 0x80 /* Error */
50		50
51	static volatile struct NS16550 __iomem *udbg_comport;	51	static volatile struct NS16550 __iomem *udbg_comport;
52		52
53	static void udbg_550_putc(unsigned char c)	53	static void udbg_550_putc(unsigned char c)
54	{	54	{
55	if (udbg_comport) {	55	if (udbg_comport) {
56	while ((in_8(&udbg_comport->lsr) & LSR_THRE) == 0)	56	while ((in_8(&udbg_comport->lsr) & LSR_THRE) == 0)
57	/* wait for idle */;	57	/* wait for idle */;
58	out_8(&udbg_comport->thr, c);	58	out_8(&udbg_comport->thr, c);
59	if (c == '\n')	59	if (c == '\n')
60	udbg_550_putc('\r');	60	udbg_550_putc('\r');
61	}	61	}
62	}	62	}
63		63
64	static int udbg_550_getc_poll(void)	64	static int udbg_550_getc_poll(void)
65	{	65	{
66	if (udbg_comport) {	66	if (udbg_comport) {
67	if ((in_8(&udbg_comport->lsr) & LSR_DR) != 0)	67	if ((in_8(&udbg_comport->lsr) & LSR_DR) != 0)
68	return in_8(&udbg_comport->rbr);	68	return in_8(&udbg_comport->rbr);
69	else	69	else
70	return -1;	70	return -1;
71	}	71	}
72	return -1;	72	return -1;
73	}	73	}
74		74
75	static unsigned char udbg_550_getc(void)	75	static unsigned char udbg_550_getc(void)
76	{	76	{
77	if (udbg_comport) {	77	if (udbg_comport) {
78	while ((in_8(&udbg_comport->lsr) & LSR_DR) == 0)	78	while ((in_8(&udbg_comport->lsr) & LSR_DR) == 0)
79	/* wait for char */;	79	/* wait for char */;
80	return in_8(&udbg_comport->rbr);	80	return in_8(&udbg_comport->rbr);
81	}	81	}
82	return 0;	82	return 0;
83	}	83	}
84		84
85	void udbg_init_uart(void __iomem *comport, unsigned int speed)	85	void udbg_init_uart(void __iomem *comport, unsigned int speed)
86	{	86	{
87	u16 dll = speed ? (115200 / speed) : 12;	87	u16 dll = speed ? (115200 / speed) : 12;
88		88
89	if (comport) {	89	if (comport) {
90	udbg_comport = (struct NS16550 __iomem *)comport;	90	udbg_comport = (struct NS16550 __iomem *)comport;
91	out_8(&udbg_comport->lcr, 0x00);	91	out_8(&udbg_comport->lcr, 0x00);
92	out_8(&udbg_comport->ier, 0xff);	92	out_8(&udbg_comport->ier, 0xff);
93	out_8(&udbg_comport->ier, 0x00);	93	out_8(&udbg_comport->ier, 0x00);
94	out_8(&udbg_comport->lcr, 0x80); /* Access baud rate */	94	out_8(&udbg_comport->lcr, 0x80); /* Access baud rate */
95	out_8(&udbg_comport->dll, dll & 0xff); /* 1 = 115200, 2 = 57600,	95	out_8(&udbg_comport->dll, dll & 0xff); /* 1 = 115200, 2 = 57600,
96	3 = 38400, 12 = 9600 baud */	96	3 = 38400, 12 = 9600 baud */
97	out_8(&udbg_comport->dlm, dll >> 8); /* dll >> 8 which should be zero	97	out_8(&udbg_comport->dlm, dll >> 8); /* dll >> 8 which should be zero
98	for fast rates; */	98	for fast rates; */
99	out_8(&udbg_comport->lcr, 0x03); /* 8 data, 1 stop, no parity */	99	out_8(&udbg_comport->lcr, 0x03); /* 8 data, 1 stop, no parity */
100	out_8(&udbg_comport->mcr, 0x03); /* RTS/DTR */	100	out_8(&udbg_comport->mcr, 0x03); /* RTS/DTR */
101	out_8(&udbg_comport->fcr ,0x07); /* Clear & enable FIFOs */	101	out_8(&udbg_comport->fcr ,0x07); /* Clear & enable FIFOs */
102	ppc_md.udbg_putc = udbg_550_putc;	102	udbg_putc = udbg_550_putc;
103	ppc_md.udbg_getc = udbg_550_getc;	103	udbg_getc = udbg_550_getc;
104	ppc_md.udbg_getc_poll = udbg_550_getc_poll;	104	udbg_getc_poll = udbg_550_getc_poll;
105	}	105	}
106	}	106	}
107		107
108	#ifdef CONFIG_PPC_MAPLE	108	#ifdef CONFIG_PPC_MAPLE
109	void udbg_maple_real_putc(unsigned char c)	109	void udbg_maple_real_putc(unsigned char c)
110	{	110	{
111	if (udbg_comport) {	111	if (udbg_comport) {
112	while ((real_readb(&udbg_comport->lsr) & LSR_THRE) == 0)	112	while ((real_readb(&udbg_comport->lsr) & LSR_THRE) == 0)
113	/* wait for idle */;	113	/* wait for idle */;
114	real_writeb(c, &udbg_comport->thr); eieio();	114	real_writeb(c, &udbg_comport->thr); eieio();
115	if (c == '\n')	115	if (c == '\n')
116	udbg_maple_real_putc('\r');	116	udbg_maple_real_putc('\r');
117	}	117	}
118	}	118	}
119		119
120	void udbg_init_maple_realmode(void)	120	void udbg_init_maple_realmode(void)
121	{	121	{
122	udbg_comport = (volatile struct NS16550 __iomem *)0xf40003f8;	122	udbg_comport = (volatile struct NS16550 __iomem *)0xf40003f8;
123		123
124	ppc_md.udbg_putc = udbg_maple_real_putc;	124	udbg_putc = udbg_maple_real_putc;
125	ppc_md.udbg_getc = NULL;	125	udbg_getc = NULL;
126	ppc_md.udbg_getc_poll = NULL;	126	udbg_getc_poll = NULL;
127	}	127	}
128	#endif /* CONFIG_PPC_MAPLE */	128	#endif /* CONFIG_PPC_MAPLE */
129		129

arch/ppc64/kernel/udbg_scc.c

Diff comments View file @ c8f1c8b

1	/*	1	/*
2	* udbg for for zilog scc ports as found on Apple PowerMacs	2	* udbg for for zilog scc ports as found on Apple PowerMacs
3	*	3	*
4	* Copyright (C) 2001-2005 PPC 64 Team, IBM Corp	4	* Copyright (C) 2001-2005 PPC 64 Team, IBM Corp
5	*	5	*
6	* This program is free software; you can redistribute it and/or	6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License	7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version	8	* as published by the Free Software Foundation; either version
9	* 2 of the License, or (at your option) any later version.	9	* 2 of the License, or (at your option) any later version.
10	*/	10	*/
11	#include <linux/config.h>	11	#include <linux/config.h>
12	#include <linux/types.h>	12	#include <linux/types.h>
13	#include <asm/ppcdebug.h>	13	#include <asm/ppcdebug.h>
14	#include <asm/processor.h>	14	#include <asm/processor.h>
15	#include <asm/naca.h>	15	#include <asm/naca.h>
16	#include <asm/uaccess.h>	16	#include <asm/uaccess.h>
17	#include <asm/machdep.h>	17	#include <asm/machdep.h>
18	#include <asm/io.h>	18	#include <asm/io.h>
19	#include <asm/prom.h>	19	#include <asm/prom.h>
20	#include <asm/pmac_feature.h>	20	#include <asm/pmac_feature.h>
21		21
22	extern u8 real_readb(volatile u8 __iomem *addr);	22	extern u8 real_readb(volatile u8 __iomem *addr);
23	extern void real_writeb(u8 data, volatile u8 __iomem *addr);	23	extern void real_writeb(u8 data, volatile u8 __iomem *addr);
24		24
25	#define SCC_TXRDY 4	25	#define SCC_TXRDY 4
26	#define SCC_RXRDY 1	26	#define SCC_RXRDY 1
27		27
28	static volatile u8 __iomem *sccc;	28	static volatile u8 __iomem *sccc;
29	static volatile u8 __iomem *sccd;	29	static volatile u8 __iomem *sccd;
30		30
31	static void udbg_scc_putc(unsigned char c)	31	static void udbg_scc_putc(unsigned char c)
32	{	32	{
33	if (sccc) {	33	if (sccc) {
34	while ((in_8(sccc) & SCC_TXRDY) == 0)	34	while ((in_8(sccc) & SCC_TXRDY) == 0)
35	;	35	;
36	out_8(sccd, c);	36	out_8(sccd, c);
37	if (c == '\n')	37	if (c == '\n')
38	udbg_scc_putc('\r');	38	udbg_scc_putc('\r');
39	}	39	}
40	}	40	}
41		41
42	static int udbg_scc_getc_poll(void)	42	static int udbg_scc_getc_poll(void)
43	{	43	{
44	if (sccc) {	44	if (sccc) {
45	if ((in_8(sccc) & SCC_RXRDY) != 0)	45	if ((in_8(sccc) & SCC_RXRDY) != 0)
46	return in_8(sccd);	46	return in_8(sccd);
47	else	47	else
48	return -1;	48	return -1;
49	}	49	}
50	return -1;	50	return -1;
51	}	51	}
52		52
53	static unsigned char udbg_scc_getc(void)	53	static unsigned char udbg_scc_getc(void)
54	{	54	{
55	if (sccc) {	55	if (sccc) {
56	while ((in_8(sccc) & SCC_RXRDY) == 0)	56	while ((in_8(sccc) & SCC_RXRDY) == 0)
57	;	57	;
58	return in_8(sccd);	58	return in_8(sccd);
59	}	59	}
60	return 0;	60	return 0;
61	}	61	}
62		62
63	static unsigned char scc_inittab[] = {	63	static unsigned char scc_inittab[] = {
64	13, 0, /* set baud rate divisor */	64	13, 0, /* set baud rate divisor */
65	12, 0,	65	12, 0,
66	14, 1, /* baud rate gen enable, src=rtxc */	66	14, 1, /* baud rate gen enable, src=rtxc */
67	11, 0x50, /* clocks = br gen */	67	11, 0x50, /* clocks = br gen */
68	5, 0xea, /* tx 8 bits, assert DTR & RTS */	68	5, 0xea, /* tx 8 bits, assert DTR & RTS */
69	4, 0x46, /* x16 clock, 1 stop */	69	4, 0x46, /* x16 clock, 1 stop */
70	3, 0xc1, /* rx enable, 8 bits */	70	3, 0xc1, /* rx enable, 8 bits */
71	};	71	};
72		72
73	void udbg_init_scc(struct device_node *np)	73	void udbg_init_scc(struct device_node *np)
74	{	74	{
75	u32 *reg;	75	u32 *reg;
76	unsigned long addr;	76	unsigned long addr;
77	int i, x;	77	int i, x;
78		78
79	if (np == NULL)	79	if (np == NULL)
80	np = of_find_node_by_name(NULL, "escc");	80	np = of_find_node_by_name(NULL, "escc");
81	if (np == NULL \|\| np->parent == NULL)	81	if (np == NULL \|\| np->parent == NULL)
82	return;	82	return;
83		83
84	udbg_printf("found SCC...\n");	84	udbg_printf("found SCC...\n");
85	/* Get address within mac-io ASIC */	85	/* Get address within mac-io ASIC */
86	reg = (u32 *)get_property(np, "reg", NULL);	86	reg = (u32 *)get_property(np, "reg", NULL);
87	if (reg == NULL)	87	if (reg == NULL)
88	return;	88	return;
89	addr = reg[0];	89	addr = reg[0];
90	udbg_printf("local addr: %lx\n", addr);	90	udbg_printf("local addr: %lx\n", addr);
91	/* Get address of mac-io PCI itself */	91	/* Get address of mac-io PCI itself */
92	reg = (u32 *)get_property(np->parent, "assigned-addresses", NULL);	92	reg = (u32 *)get_property(np->parent, "assigned-addresses", NULL);
93	if (reg == NULL)	93	if (reg == NULL)
94	return;	94	return;
95	addr += reg[2];	95	addr += reg[2];
96	udbg_printf("final addr: %lx\n", addr);	96	udbg_printf("final addr: %lx\n", addr);
97		97
98	/* Setup for 57600 8N1 */	98	/* Setup for 57600 8N1 */
99	addr += 0x20;	99	addr += 0x20;
100	sccc = (volatile u8 * __iomem) ioremap(addr & PAGE_MASK, PAGE_SIZE) ;	100	sccc = (volatile u8 * __iomem) ioremap(addr & PAGE_MASK, PAGE_SIZE) ;
101	sccc += addr & ~PAGE_MASK;	101	sccc += addr & ~PAGE_MASK;
102	sccd = sccc + 0x10;	102	sccd = sccc + 0x10;
103		103
104	udbg_printf("ioremap result sccc: %p\n", sccc);	104	udbg_printf("ioremap result sccc: %p\n", sccc);
105	mb();	105	mb();
106		106
107	for (i = 20000; i != 0; --i)	107	for (i = 20000; i != 0; --i)
108	x = in_8(sccc);	108	x = in_8(sccc);
109	out_8(sccc, 0x09); /* reset A or B side */	109	out_8(sccc, 0x09); /* reset A or B side */
110	out_8(sccc, 0xc0);	110	out_8(sccc, 0xc0);
111	for (i = 0; i < sizeof(scc_inittab); ++i)	111	for (i = 0; i < sizeof(scc_inittab); ++i)
112	out_8(sccc, scc_inittab[i]);	112	out_8(sccc, scc_inittab[i]);
113		113
114	ppc_md.udbg_putc = udbg_scc_putc;	114	udbg_putc = udbg_scc_putc;
115	ppc_md.udbg_getc = udbg_scc_getc;	115	udbg_getc = udbg_scc_getc;
116	ppc_md.udbg_getc_poll = udbg_scc_getc_poll;	116	udbg_getc_poll = udbg_scc_getc_poll;
117		117
118	udbg_puts("Hello World !\n");	118	udbg_puts("Hello World !\n");
119	}	119	}
120		120
121	static void udbg_real_scc_putc(unsigned char c)	121	static void udbg_real_scc_putc(unsigned char c)
122	{	122	{
123	while ((real_readb(sccc) & SCC_TXRDY) == 0)	123	while ((real_readb(sccc) & SCC_TXRDY) == 0)
124	;	124	;
125	real_writeb(c, sccd);	125	real_writeb(c, sccd);
126	if (c == '\n')	126	if (c == '\n')
127	udbg_real_scc_putc('\r');	127	udbg_real_scc_putc('\r');
128	}	128	}
129		129
130	void udbg_init_pmac_realmode(void)	130	void udbg_init_pmac_realmode(void)
131	{	131	{
132	sccc = (volatile u8 __iomem *)0x80013020ul;	132	sccc = (volatile u8 __iomem *)0x80013020ul;
133	sccd = (volatile u8 __iomem *)0x80013030ul;	133	sccd = (volatile u8 __iomem *)0x80013030ul;
134		134
135	ppc_md.udbg_putc = udbg_real_scc_putc;	135	udbg_putc = udbg_real_scc_putc;
136	ppc_md.udbg_getc = NULL;	136	udbg_getc = NULL;
137	ppc_md.udbg_getc_poll = NULL;	137	udbg_getc_poll = NULL;
138	}	138	}
139		139

arch/ppc64/xmon/start.c

Diff comments View file @ c8f1c8b

1	/*	1	/*
2	* Copyright (C) 1996 Paul Mackerras.	2	* Copyright (C) 1996 Paul Mackerras.
3	*	3	*
4	* This program is free software; you can redistribute it and/or	4	* This program is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU General Public License	5	* modify it under the terms of the GNU General Public License
6	* as published by the Free Software Foundation; either version	6	* as published by the Free Software Foundation; either version
7	* 2 of the License, or (at your option) any later version.	7	* 2 of the License, or (at your option) any later version.
8	*/	8	*/
9	#include <linux/config.h>	9	#include <linux/config.h>
10	#include <linux/string.h>	10	#include <linux/string.h>
11	#include <linux/kernel.h>	11	#include <linux/kernel.h>
12	#include <linux/errno.h>	12	#include <linux/errno.h>
13	#include <linux/sysrq.h>	13	#include <linux/sysrq.h>
14	#include <linux/init.h>	14	#include <linux/init.h>
15	#include <asm/machdep.h>	15	#include <asm/machdep.h>
16	#include <asm/io.h>	16	#include <asm/io.h>
17	#include <asm/page.h>	17	#include <asm/page.h>
18	#include <asm/prom.h>	18	#include <asm/prom.h>
19	#include <asm/processor.h>	19	#include <asm/processor.h>
20	#include <asm/udbg.h>	20	#include <asm/udbg.h>
21	#include <asm/system.h>	21	#include <asm/system.h>
22	#include "nonstdio.h"	22	#include "nonstdio.h"
23		23
24	#ifdef CONFIG_MAGIC_SYSRQ	24	#ifdef CONFIG_MAGIC_SYSRQ
25		25
26	static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs,	26	static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs,
27	struct tty_struct *tty)	27	struct tty_struct *tty)
28	{	28	{
29	/* ensure xmon is enabled */	29	/* ensure xmon is enabled */
30	xmon_init(1);	30	xmon_init(1);
31	debugger(pt_regs);	31	debugger(pt_regs);
32	}	32	}
33		33
34	static struct sysrq_key_op sysrq_xmon_op =	34	static struct sysrq_key_op sysrq_xmon_op =
35	{	35	{
36	.handler = sysrq_handle_xmon,	36	.handler = sysrq_handle_xmon,
37	.help_msg = "Xmon",	37	.help_msg = "Xmon",
38	.action_msg = "Entering xmon",	38	.action_msg = "Entering xmon",
39	};	39	};
40		40
41	static int __init setup_xmon_sysrq(void)	41	static int __init setup_xmon_sysrq(void)
42	{	42	{
43	register_sysrq_key('x', &sysrq_xmon_op);	43	register_sysrq_key('x', &sysrq_xmon_op);
44	return 0;	44	return 0;
45	}	45	}
46	__initcall(setup_xmon_sysrq);	46	__initcall(setup_xmon_sysrq);
47	#endif /* CONFIG_MAGIC_SYSRQ */	47	#endif /* CONFIG_MAGIC_SYSRQ */
48		48
49	int	49	int
50	xmon_write(void handle, void ptr, int nb)	50	xmon_write(void handle, void ptr, int nb)
51	{	51	{
52	return udbg_write(ptr, nb);	52	return udbg_write(ptr, nb);
53	}	53	}
54		54
55	int	55	int
56	xmon_read(void handle, void ptr, int nb)	56	xmon_read(void handle, void ptr, int nb)
57	{	57	{
58	return udbg_read(ptr, nb);	58	return udbg_read(ptr, nb);
59	}	59	}
60		60
61	int	61	int
62	xmon_read_poll(void)	62	xmon_read_poll(void)
63	{	63	{
64	if (ppc_md.udbg_getc_poll)	64	if (udbg_getc_poll)
65	return ppc_md.udbg_getc_poll();	65	return udbg_getc_poll();
66	return -1;	66	return -1;
67	}	67	}
68		68
69	FILE *xmon_stdin;	69	FILE *xmon_stdin;
70	FILE *xmon_stdout;	70	FILE *xmon_stdout;
71		71
72	int	72	int
73	xmon_putc(int c, void *f)	73	xmon_putc(int c, void *f)
74	{	74	{
75	char ch = c;	75	char ch = c;
76		76
77	if (c == '\n')	77	if (c == '\n')
78	xmon_putc('\r', f);	78	xmon_putc('\r', f);
79	return xmon_write(f, &ch, 1) == 1? c: -1;	79	return xmon_write(f, &ch, 1) == 1? c: -1;
80	}	80	}
81		81
82	int	82	int
83	xmon_putchar(int c)	83	xmon_putchar(int c)
84	{	84	{
85	return xmon_putc(c, xmon_stdout);	85	return xmon_putc(c, xmon_stdout);
86	}	86	}
87		87
88	int	88	int
89	xmon_fputs(char str, void f)	89	xmon_fputs(char str, void f)
90	{	90	{
91	int n = strlen(str);	91	int n = strlen(str);
92		92
93	return xmon_write(f, str, n) == n? 0: -1;	93	return xmon_write(f, str, n) == n? 0: -1;
94	}	94	}
95		95
96	int	96	int
97	xmon_readchar(void)	97	xmon_readchar(void)
98	{	98	{
99	char ch;	99	char ch;
100		100
101	for (;;) {	101	for (;;) {
102	switch (xmon_read(xmon_stdin, &ch, 1)) {	102	switch (xmon_read(xmon_stdin, &ch, 1)) {
103	case 1:	103	case 1:
104	return ch;	104	return ch;
105	case -1:	105	case -1:
106	xmon_printf("read(stdin) returned -1\r\n", 0, 0);	106	xmon_printf("read(stdin) returned -1\r\n", 0, 0);
107	return -1;	107	return -1;
108	}	108	}
109	}	109	}
110	}	110	}
111		111
112	static char line[256];	112	static char line[256];
113	static char *lineptr;	113	static char *lineptr;
114	static int lineleft;	114	static int lineleft;
115		115
116	int	116	int
117	xmon_getchar(void)	117	xmon_getchar(void)
118	{	118	{
119	int c;	119	int c;
120		120
121	if (lineleft == 0) {	121	if (lineleft == 0) {
122	lineptr = line;	122	lineptr = line;
123	for (;;) {	123	for (;;) {
124	c = xmon_readchar();	124	c = xmon_readchar();
125	if (c == -1 \|\| c == 4)	125	if (c == -1 \|\| c == 4)
126	break;	126	break;
127	if (c == '\r' \|\| c == '\n') {	127	if (c == '\r' \|\| c == '\n') {
128	*lineptr++ = '\n';	128	*lineptr++ = '\n';
129	xmon_putchar('\n');	129	xmon_putchar('\n');
130	break;	130	break;
131	}	131	}
132	switch (c) {	132	switch (c) {
133	case 0177:	133	case 0177:
134	case '\b':	134	case '\b':
135	if (lineptr > line) {	135	if (lineptr > line) {
136	xmon_putchar('\b');	136	xmon_putchar('\b');
137	xmon_putchar(' ');	137	xmon_putchar(' ');
138	xmon_putchar('\b');	138	xmon_putchar('\b');
139	--lineptr;	139	--lineptr;
140	}	140	}
141	break;	141	break;
142	case 'U' & 0x1F:	142	case 'U' & 0x1F:
143	while (lineptr > line) {	143	while (lineptr > line) {
144	xmon_putchar('\b');	144	xmon_putchar('\b');
145	xmon_putchar(' ');	145	xmon_putchar(' ');
146	xmon_putchar('\b');	146	xmon_putchar('\b');
147	--lineptr;	147	--lineptr;
148	}	148	}
149	break;	149	break;
150	default:	150	default:
151	if (lineptr >= &line[sizeof(line) - 1])	151	if (lineptr >= &line[sizeof(line) - 1])
152	xmon_putchar('\a');	152	xmon_putchar('\a');
153	else {	153	else {
154	xmon_putchar(c);	154	xmon_putchar(c);
155	*lineptr++ = c;	155	*lineptr++ = c;
156	}	156	}
157	}	157	}
158	}	158	}
159	lineleft = lineptr - line;	159	lineleft = lineptr - line;
160	lineptr = line;	160	lineptr = line;
161	}	161	}
162	if (lineleft == 0)	162	if (lineleft == 0)
163	return -1;	163	return -1;
164	--lineleft;	164	--lineleft;
165	return *lineptr++;	165	return *lineptr++;
166	}	166	}
167		167
168	char *	168	char *
169	xmon_fgets(char str, int nb, void f)	169	xmon_fgets(char str, int nb, void f)
170	{	170	{
171	char *p;	171	char *p;
172	int c;	172	int c;
173		173
174	for (p = str; p < str + nb - 1; ) {	174	for (p = str; p < str + nb - 1; ) {
175	c = xmon_getchar();	175	c = xmon_getchar();
176	if (c == -1) {	176	if (c == -1) {
177	if (p == str)	177	if (p == str)
178	return NULL;	178	return NULL;
179	break;	179	break;
180	}	180	}
181	*p++ = c;	181	*p++ = c;
182	if (c == '\n')	182	if (c == '\n')
183	break;	183	break;
184	}	184	}
185	*p = 0;	185	*p = 0;
186	return str;	186	return str;
187	}	187	}
188		188

include/asm-ppc64/machdep.h

Diff comments View file @ c8f1c8b

 #ifdef __KERNEL__
 #ifndef _PPC64_MACHDEP_H
 #define _PPC64_MACHDEP_H
 /*
  * 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/config.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
 #include <asm/setup.h>
 struct pt_regs;
 struct pci_bus;
 struct device_node;
 struct iommu_table;
 struct rtc_time;
 struct file;
 #ifdef CONFIG_SMP
 struct smp_ops_t {
 	void  (*message_pass)(int target, int msg);
 	int   (*probe)(void);
 	void  (*kick_cpu)(int nr);
 	void  (*setup_cpu)(int nr);
 	void  (*take_timebase)(void);
 	void  (*give_timebase)(void);
 	int   (*cpu_enable)(unsigned int nr);
 	int   (*cpu_disable)(void);
 	void  (*cpu_die)(unsigned int nr);
 	int   (*cpu_bootable)(unsigned int nr);
 };
 #endif
 struct machdep_calls {
 	void            (*hpte_invalidate)(unsigned long slot,
 					   unsigned long va,
 					   int large,
 					   int local);
 	long		(*hpte_updatepp)(unsigned long slot,
 					 unsigned long newpp,
 					 unsigned long va,
 					 int large,
 					 int local);
 	void            (*hpte_updateboltedpp)(unsigned long newpp,
 					       unsigned long ea);
 	long		(*hpte_insert)(unsigned long hpte_group,
 				       unsigned long va,
 				       unsigned long prpn,
 				       unsigned long vflags,
 				       unsigned long rflags);
 	long		(*hpte_remove)(unsigned long hpte_group);
 	void		(*flush_hash_range)(unsigned long context,
 					    unsigned long number,
 					    int local);
 	/* special for kexec, to be called in real mode, linar mapping is
 	 * destroyed as well */
 	void		(*hpte_clear_all)(void);
 	void		(*tce_build)(struct iommu_table * tbl,
 				     long index,
 				     long npages,
 				     unsigned long uaddr,
 				     enum dma_data_direction direction);
 	void		(*tce_free)(struct iommu_table *tbl,
 				    long index,
 				    long npages);
 	void		(*tce_flush)(struct iommu_table *tbl);
 	void		(*iommu_dev_setup)(struct pci_dev *dev);
 	void		(*iommu_bus_setup)(struct pci_bus *bus);
 	void		(*irq_bus_setup)(struct pci_bus *bus);
 	int		(*probe)(int platform);
 	void		(*setup_arch)(void);
 	void		(*init_early)(void);
 	/* Optional, may be NULL. */
 	void		(*get_cpuinfo)(struct seq_file *m);
 	void		(*init_IRQ)(void);
 	int		(*get_irq)(struct pt_regs *);
 	void		(*cpu_irq_down)(int secondary);
 	/* PCI stuff */
 	void		(*pcibios_fixup)(void);
 	void		(*restart)(char *cmd);
 	void		(*power_off)(void);
 	void		(*halt)(void);
 	void		(*panic)(char *str);
 	void		(*cpu_die)(void);
 	int		(*set_rtc_time)(struct rtc_time *);
 	void		(*get_rtc_time)(struct rtc_time *);
 	void		(*get_boot_time)(struct rtc_time *);
 	void		(*calibrate_decr)(void);
 	void		(*progress)(char *, unsigned short);
-	/* Debug interface.  Low level I/O to some terminal device */
-	void		(*udbg_putc)(unsigned char c);
-	unsigned char	(*udbg_getc)(void);
-	int		(*udbg_getc_poll)(void);
 	/* Interface for platform error logging */
 	void 		(*log_error)(char *buf, unsigned int err_type, int fatal);
 	ssize_t		(*nvram_write)(char *buf, size_t count, loff_t *index);
 	ssize_t		(*nvram_read)(char *buf, size_t count, loff_t *index);
 	ssize_t		(*nvram_size)(void);
 	int		(*nvram_sync)(void);
 	/* Exception handlers */
 	void		(*system_reset_exception)(struct pt_regs *regs);
 	int 		(*machine_check_exception)(struct pt_regs *regs);
 	/* Motherboard/chipset features. This is a kind of general purpose
 	 * hook used to control some machine specific features (like reset
 	 * lines, chip power control, etc...).
 	 */
 	long	 	(*feature_call)(unsigned int feature, ...);
 	/* Check availability of legacy devices like i8042 */
 	int 		(*check_legacy_ioport)(unsigned int baseport);
 	/* Get legacy PCI/IDE interrupt mapping */
 	int		(*pci_get_legacy_ide_irq)(struct pci_dev *dev, int channel);
 	/* Get access protection for /dev/mem */
 	pgprot_t	(*phys_mem_access_prot)(struct file *file,
 						unsigned long offset,
 						unsigned long size,
 						pgprot_t vma_prot);
 	/* Idle loop for this platform, leave empty for default idle loop */
 	int		(*idle_loop)(void);
 	/* Function to enable pmcs for this platform, called once per cpu. */
 	void		(*enable_pmcs)(void);
 };
 extern int default_idle(void);
 extern int native_idle(void);
 extern struct machdep_calls ppc_md;
 extern char cmd_line[COMMAND_LINE_SIZE];
 #ifdef CONFIG_PPC_PMAC
 /*
  * Power macintoshes have either a CUDA, PMU or SMU controlling
  * system reset, power, NVRAM, RTC.
  */
 typedef enum sys_ctrler_kind {
 	SYS_CTRLER_UNKNOWN = 0,
 	SYS_CTRLER_CUDA = 1,
 	SYS_CTRLER_PMU = 2,
 	SYS_CTRLER_SMU = 3,
 } sys_ctrler_t;
 extern sys_ctrler_t sys_ctrler;
 #endif /* CONFIG_PPC_PMAC */
 /* Functions to produce codes on the leds.
  * The SRC code should be unique for the message category and should
  * be limited to the lower 24 bits (the upper 8 are set by these funcs),
  * and (for boot & dump) should be sorted numerically in the order
  * the events occur.
  */
 /* Print a boot progress message. */
 void ppc64_boot_msg(unsigned int src, const char *msg);
 /* Print a termination message (print only -- does not stop the kernel) */
 void ppc64_terminate_msg(unsigned int src, const char *msg);
 /* Print something that needs attention (device error, etc) */
 void ppc64_attention_msg(unsigned int src, const char *msg);
 /* Print a dump progress message. */
 void ppc64_dump_msg(unsigned int src, const char *msg);
 static inline void log_error(char *buf, unsigned int err_type, int fatal)
 {
 	if (ppc_md.log_error)
 		ppc_md.log_error(buf, err_type, fatal);
 }
 #endif /* _PPC64_MACHDEP_H */
 #endif /* __KERNEL__ */

include/asm-ppc64/udbg.h

Diff comments View file @ c8f1c8b

1	#ifndef __UDBG_HDR	1	#ifndef __UDBG_HDR
2	#define __UDBG_HDR	2	#define __UDBG_HDR
3		3
4	#include <linux/compiler.h>	4	#include <linux/compiler.h>
5		5
6	/*	6	/*
7	* c 2001 PPC 64 Team, IBM Corp	7	* c 2001 PPC 64 Team, IBM Corp
8	*	8	*
9	* This program is free software; you can redistribute it and/or	9	* This program is free software; you can redistribute it and/or
10	* modify it under the terms of the GNU General Public License	10	* modify it under the terms of the GNU General Public License
11	* as published by the Free Software Foundation; either version	11	* as published by the Free Software Foundation; either version
12	* 2 of the License, or (at your option) any later version.	12	* 2 of the License, or (at your option) any later version.
13	*/	13	*/
14		14
15	void udbg_init_uart(void __iomem *comport, unsigned int speed);	15	extern void (*udbg_putc)(unsigned char c);
16	void udbg_putc(unsigned char c);	16	extern unsigned char (*udbg_getc)(void);
17	unsigned char udbg_getc(void);	17	extern int (*udbg_getc_poll)(void);
18	int udbg_getc_poll(void);	18
19	void udbg_puts(const char *s);	19	extern void udbg_puts(const char *s);
20	int udbg_write(const char *s, int n);	20	extern int udbg_write(const char *s, int n);
21	int udbg_read(char *buf, int buflen);	21	extern int udbg_read(char *buf, int buflen);
		22
22	struct console;	23	struct console;
23	void udbg_console_write(struct console con, const char s, unsigned int n);	24	extern void udbg_console_write(struct console con, const char s, unsigned int n);
24	void udbg_printf(const char *fmt, ...);	25	extern void udbg_printf(const char *fmt, ...);
25	void udbg_ppcdbg(unsigned long flags, const char *fmt, ...);	26	extern void udbg_ppcdbg(unsigned long flags, const char *fmt, ...);
26	unsigned long udbg_ifdebug(unsigned long flags);	27	extern unsigned long udbg_ifdebug(unsigned long flags);
27		28
		29
		30	extern void udbg_init_uart(void __iomem *comport, unsigned int speed);
28	#endif	31	#endif
29		32